graal-jvmci-8: src/share/vm/memory/sharedHeap.hpp annotate

annotate src/share/vm/memory/sharedHeap.hpp @ 12233:40136aa2cdb1

8010722: assert: failed: heap size is too big for compressed oops Summary: Use conservative assumptions of required alignment for the various garbage collector components into account when determining the maximum heap size that supports compressed oops. Using this conservative value avoids several circular dependencies in the calculation. Reviewed-by: stefank, dholmes

author	tschatzl
date	Wed, 11 Sep 2013 16:25:02 +0200
parents	71180a6e5080
children	de6a9e811145

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4728 diff changeset	2 * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1088 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1088 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1088 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	25 #ifndef SHARE_VM_MEMORY_SHAREDHEAP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	26 #define SHARE_VM_MEMORY_SHAREDHEAP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	28 #include "gc_interface/collectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	29 #include "memory/generation.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	30
0 a61af66fc99e Initial load duke parents: diff changeset	31 // A "SharedHeap" is an implementation of a java heap for HotSpot. This
a61af66fc99e Initial load duke parents: diff changeset	32 // is an abstract class: there may be many different kinds of heaps. This
a61af66fc99e Initial load duke parents: diff changeset	33 // class defines the functions that a heap must implement, and contains
a61af66fc99e Initial load duke parents: diff changeset	34 // infrastructure common to all heaps.
a61af66fc99e Initial load duke parents: diff changeset	35
a61af66fc99e Initial load duke parents: diff changeset	36 class Generation;
a61af66fc99e Initial load duke parents: diff changeset	37 class BarrierSet;
a61af66fc99e Initial load duke parents: diff changeset	38 class GenRemSet;
a61af66fc99e Initial load duke parents: diff changeset	39 class Space;
a61af66fc99e Initial load duke parents: diff changeset	40 class SpaceClosure;
a61af66fc99e Initial load duke parents: diff changeset	41 class OopClosure;
a61af66fc99e Initial load duke parents: diff changeset	42 class OopsInGenClosure;
a61af66fc99e Initial load duke parents: diff changeset	43 class ObjectClosure;
a61af66fc99e Initial load duke parents: diff changeset	44 class SubTasksDone;
a61af66fc99e Initial load duke parents: diff changeset	45 class WorkGang;
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	46 class FlexibleWorkGang;
0 a61af66fc99e Initial load duke parents: diff changeset	47 class CollectorPolicy;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4728 diff changeset	48 class KlassClosure;
0 a61af66fc99e Initial load duke parents: diff changeset	49
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	50 // Note on use of FlexibleWorkGang's for GC.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	51 // There are three places where task completion is determined.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	52 // In
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	53 // 1) ParallelTaskTerminator::offer_termination() where _n_threads
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	54 // must be set to the correct value so that count of workers that
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	55 // have offered termination will exactly match the number
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	56 // working on the task. Tasks such as those derived from GCTask
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	57 // use ParallelTaskTerminator's. Tasks that want load balancing
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	58 // by work stealing use this method to gauge completion.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	59 // 2) SubTasksDone has a variable _n_threads that is used in
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	60 // all_tasks_completed() to determine completion. all_tasks_complete()
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	61 // counts the number of tasks that have been done and then reset
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	62 // the SubTasksDone so that it can be used again. When the number of
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	63 // tasks is set to the number of GC workers, then _n_threads must
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	64 // be set to the number of active GC workers. G1CollectedHeap,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	65 // HRInto_G1RemSet, GenCollectedHeap and SharedHeap have SubTasksDone.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	66 // This seems too many.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	67 // 3) SequentialSubTasksDone has an _n_threads that is used in
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	68 // a way similar to SubTasksDone and has the same dependency on the
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	69 // number of active GC workers. CompactibleFreeListSpace and Space
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	70 // have SequentialSubTasksDone's.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	71 // Example of using SubTasksDone and SequentialSubTasksDone
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	72 // G1CollectedHeap::g1_process_strong_roots() calls
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	73 // process_strong_roots(false, // no scoping; this is parallel code
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4728 diff changeset	74 // is_scavenging, so,
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	75 // &buf_scan_non_heap_roots,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4728 diff changeset	76 // &eager_scan_code_roots);
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	77 // which delegates to SharedHeap::process_strong_roots() and uses
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	78 // SubTasksDone* _process_strong_tasks to claim tasks.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	79 // process_strong_roots() calls
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4728 diff changeset	80 // rem_set()->younger_refs_iterate()
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	81 // to scan the card table and which eventually calls down into
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	82 // CardTableModRefBS::par_non_clean_card_iterate_work(). This method
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	83 // uses SequentialSubTasksDone* _pst to claim tasks.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	84 // Both SubTasksDone and SequentialSubTasksDone call their method
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	85 // all_tasks_completed() to count the number of GC workers that have
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	86 // finished their work. That logic is "when all the workers are
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	87 // finished the tasks are finished".
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	88 //
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	89 // The pattern that appears in the code is to set _n_threads
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	90 // to a value > 1 before a task that you would like executed in parallel
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	91 // and then to set it to 0 after that task has completed. A value of
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	92 // 0 is a "special" value in set_n_threads() which translates to
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	93 // setting _n_threads to 1.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	94 //
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	95 // Some code uses _n_terminiation to decide if work should be done in
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	96 // parallel. The notorious possibly_parallel_oops_do() in threads.cpp
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	97 // is an example of such code. Look for variable "is_par" for other
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	98 // examples.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	99 //
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	100 // The active_workers is not reset to 0 after a parallel phase. It's
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	101 // value may be used in later phases and in one instance at least
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	102 // (the parallel remark) it has to be used (the parallel remark depends
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	103 // on the partitioning done in the previous parallel scavenge).
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	104
0 a61af66fc99e Initial load duke parents: diff changeset	105 class SharedHeap : public CollectedHeap {
a61af66fc99e Initial load duke parents: diff changeset	106 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	107
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	108 friend class VM_GC_Operation;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	109 friend class VM_CGC_Operation;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	110
0 a61af66fc99e Initial load duke parents: diff changeset	111 private:
a61af66fc99e Initial load duke parents: diff changeset	112 // For claiming strong_roots tasks.
a61af66fc99e Initial load duke parents: diff changeset	113 SubTasksDone* _process_strong_tasks;
a61af66fc99e Initial load duke parents: diff changeset	114
a61af66fc99e Initial load duke parents: diff changeset	115 protected:
a61af66fc99e Initial load duke parents: diff changeset	116 // There should be only a single instance of "SharedHeap" in a program.
a61af66fc99e Initial load duke parents: diff changeset	117 // This is enforced with the protected constructor below, which will also
a61af66fc99e Initial load duke parents: diff changeset	118 // set the static pointer "_sh" to that instance.
a61af66fc99e Initial load duke parents: diff changeset	119 static SharedHeap* _sh;
a61af66fc99e Initial load duke parents: diff changeset	120
a61af66fc99e Initial load duke parents: diff changeset	121 // and the Gen Remembered Set, at least one good enough to scan the perm
a61af66fc99e Initial load duke parents: diff changeset	122 // gen.
a61af66fc99e Initial load duke parents: diff changeset	123 GenRemSet* _rem_set;
a61af66fc99e Initial load duke parents: diff changeset	124
a61af66fc99e Initial load duke parents: diff changeset	125 // A gc policy, controls global gc resource issues
a61af66fc99e Initial load duke parents: diff changeset	126 CollectorPolicy *_collector_policy;
a61af66fc99e Initial load duke parents: diff changeset	127
a61af66fc99e Initial load duke parents: diff changeset	128 // See the discussion below, in the specification of the reader function
a61af66fc99e Initial load duke parents: diff changeset	129 // for this variable.
a61af66fc99e Initial load duke parents: diff changeset	130 int _strong_roots_parity;
a61af66fc99e Initial load duke parents: diff changeset	131
a61af66fc99e Initial load duke parents: diff changeset	132 // If we're doing parallel GC, use this gang of threads.
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	133 FlexibleWorkGang* _workers;
0 a61af66fc99e Initial load duke parents: diff changeset	134
a61af66fc99e Initial load duke parents: diff changeset	135 // Full initialization is done in a concrete subtype's "initialize"
a61af66fc99e Initial load duke parents: diff changeset	136 // function.
a61af66fc99e Initial load duke parents: diff changeset	137 SharedHeap(CollectorPolicy* policy_);
a61af66fc99e Initial load duke parents: diff changeset	138
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	139 // Returns true if the calling thread holds the heap lock,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	140 // or the calling thread is a par gc thread and the heap_lock is held
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	141 // by the vm thread doing a gc operation.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	142 bool heap_lock_held_for_gc();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	143 // True if the heap_lock is held by the a non-gc thread invoking a gc
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	144 // operation.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	145 bool _thread_holds_heap_lock_for_gc;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	146
0 a61af66fc99e Initial load duke parents: diff changeset	147 public:
a61af66fc99e Initial load duke parents: diff changeset	148 static SharedHeap* heap() { return _sh; }
a61af66fc99e Initial load duke parents: diff changeset	149
a61af66fc99e Initial load duke parents: diff changeset	150 void set_barrier_set(BarrierSet* bs);
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	151 SubTasksDone* process_strong_tasks() { return _process_strong_tasks; }
0 a61af66fc99e Initial load duke parents: diff changeset	152
a61af66fc99e Initial load duke parents: diff changeset	153 // Does operations required after initialization has been done.
a61af66fc99e Initial load duke parents: diff changeset	154 virtual void post_initialize();
a61af66fc99e Initial load duke parents: diff changeset	155
a61af66fc99e Initial load duke parents: diff changeset	156 // Initialization of ("weak") reference processing support
a61af66fc99e Initial load duke parents: diff changeset	157 virtual void ref_processing_init();
a61af66fc99e Initial load duke parents: diff changeset	158
a61af66fc99e Initial load duke parents: diff changeset	159 // This function returns the "GenRemSet" object that allows us to scan
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4728 diff changeset	160 // generations in a fully generational heap.
0 a61af66fc99e Initial load duke parents: diff changeset	161 GenRemSet* rem_set() { return _rem_set; }
a61af66fc99e Initial load duke parents: diff changeset	162
a61af66fc99e Initial load duke parents: diff changeset	163 // Iteration functions.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4728 diff changeset	164 void oop_iterate(ExtendedOopClosure* cl) = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	165
a61af66fc99e Initial load duke parents: diff changeset	166 // Same as above, restricted to a memory region.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4728 diff changeset	167 virtual void oop_iterate(MemRegion mr, ExtendedOopClosure* cl) = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	168
a61af66fc99e Initial load duke parents: diff changeset	169 // Iterate over all spaces in use in the heap, in an undefined order.
a61af66fc99e Initial load duke parents: diff changeset	170 virtual void space_iterate(SpaceClosure* cl) = 0;
a61af66fc99e Initial load duke parents: diff changeset	171
a61af66fc99e Initial load duke parents: diff changeset	172 // A SharedHeap will contain some number of spaces. This finds the
a61af66fc99e Initial load duke parents: diff changeset	173 // space whose reserved area contains the given address, or else returns
a61af66fc99e Initial load duke parents: diff changeset	174 // NULL.
a61af66fc99e Initial load duke parents: diff changeset	175 virtual Space* space_containing(const void* addr) const = 0;
a61af66fc99e Initial load duke parents: diff changeset	176
a61af66fc99e Initial load duke parents: diff changeset	177 bool no_gc_in_progress() { return !is_gc_active(); }
a61af66fc99e Initial load duke parents: diff changeset	178
a61af66fc99e Initial load duke parents: diff changeset	179 // Some collectors will perform "process_strong_roots" in parallel.
a61af66fc99e Initial load duke parents: diff changeset	180 // Such a call will involve claiming some fine-grained tasks, such as
a61af66fc99e Initial load duke parents: diff changeset	181 // scanning of threads. To make this process simpler, we provide the
a61af66fc99e Initial load duke parents: diff changeset	182 // "strong_roots_parity()" method. Collectors that start parallel tasks
a61af66fc99e Initial load duke parents: diff changeset	183 // whose threads invoke "process_strong_roots" must
a61af66fc99e Initial load duke parents: diff changeset	184 // call "change_strong_roots_parity" in sequential code starting such a
a61af66fc99e Initial load duke parents: diff changeset	185 // task. (This also means that a parallel thread may only call
a61af66fc99e Initial load duke parents: diff changeset	186 // process_strong_roots once.)
a61af66fc99e Initial load duke parents: diff changeset	187 //
a61af66fc99e Initial load duke parents: diff changeset	188 // For calls to process_strong_roots by sequential code, the parity is
a61af66fc99e Initial load duke parents: diff changeset	189 // updated automatically.
a61af66fc99e Initial load duke parents: diff changeset	190 //
a61af66fc99e Initial load duke parents: diff changeset	191 // The idea is that objects representing fine-grained tasks, such as
a61af66fc99e Initial load duke parents: diff changeset	192 // threads, will contain a "parity" field. A task will is claimed in the
a61af66fc99e Initial load duke parents: diff changeset	193 // current "process_strong_roots" call only if its parity field is the
a61af66fc99e Initial load duke parents: diff changeset	194 // same as the "strong_roots_parity"; task claiming is accomplished by
a61af66fc99e Initial load duke parents: diff changeset	195 // updating the parity field to the strong_roots_parity with a CAS.
a61af66fc99e Initial load duke parents: diff changeset	196 //
a61af66fc99e Initial load duke parents: diff changeset	197 // If the client meats this spec, then strong_roots_parity() will have
a61af66fc99e Initial load duke parents: diff changeset	198 // the following properties:
a61af66fc99e Initial load duke parents: diff changeset	199 // a) to return a different value than was returned before the last
a61af66fc99e Initial load duke parents: diff changeset	200 // call to change_strong_roots_parity, and
a61af66fc99e Initial load duke parents: diff changeset	201 // c) to never return a distinguished value (zero) with which such
a61af66fc99e Initial load duke parents: diff changeset	202 // task-claiming variables may be initialized, to indicate "never
a61af66fc99e Initial load duke parents: diff changeset	203 // claimed".
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	204 private:
0 a61af66fc99e Initial load duke parents: diff changeset	205 void change_strong_roots_parity();
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	206 public:
0 a61af66fc99e Initial load duke parents: diff changeset	207 int strong_roots_parity() { return _strong_roots_parity; }
a61af66fc99e Initial load duke parents: diff changeset	208
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	209 // Call these in sequential code around process_strong_roots.
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	210 // strong_roots_prologue calls change_strong_roots_parity, if
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	211 // parallel tasks are enabled.
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	212 class StrongRootsScope : public MarkingCodeBlobClosure::MarkScope {
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	213 public:
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	214 StrongRootsScope(SharedHeap* outer, bool activate = true);
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	215 ~StrongRootsScope();
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	216 };
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	217 friend class StrongRootsScope;
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	218
0 a61af66fc99e Initial load duke parents: diff changeset	219 enum ScanningOption {
a61af66fc99e Initial load duke parents: diff changeset	220 SO_None = 0x0,
a61af66fc99e Initial load duke parents: diff changeset	221 SO_AllClasses = 0x1,
a61af66fc99e Initial load duke parents: diff changeset	222 SO_SystemClasses = 0x2,
3293 1f4413413144 7039089: G1: changeset for 7037276 broke heap verification, and related cleanups ysr parents: 1972 diff changeset	223 SO_Strings = 0x4,
1f4413413144 7039089: G1: changeset for 7037276 broke heap verification, and related cleanups ysr parents: 1972 diff changeset	224 SO_CodeCache = 0x8
0 a61af66fc99e Initial load duke parents: diff changeset	225 };
a61af66fc99e Initial load duke parents: diff changeset	226
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	227 FlexibleWorkGang* workers() const { return _workers; }
0 a61af66fc99e Initial load duke parents: diff changeset	228
a61af66fc99e Initial load duke parents: diff changeset	229 // Invoke the "do_oop" method the closure "roots" on all root locations.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4728 diff changeset	230 // The "so" argument determines which roots the closure is applied to:
0 a61af66fc99e Initial load duke parents: diff changeset	231 // "SO_None" does none;
a61af66fc99e Initial load duke parents: diff changeset	232 // "SO_AllClasses" applies the closure to all entries in the SystemDictionary;
a61af66fc99e Initial load duke parents: diff changeset	233 // "SO_SystemClasses" to all the "system" classes and loaders;
a61af66fc99e Initial load duke parents: diff changeset	234 // "SO_Strings" applies the closure to all entries in StringTable;
a61af66fc99e Initial load duke parents: diff changeset	235 // "SO_CodeCache" applies the closure to all elements of the CodeCache.
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	236 void process_strong_roots(bool activate_scope,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4728 diff changeset	237 bool is_scavenging,
0 a61af66fc99e Initial load duke parents: diff changeset	238 ScanningOption so,
a61af66fc99e Initial load duke parents: diff changeset	239 OopClosure* roots,
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	240 CodeBlobClosure* code_roots,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4728 diff changeset	241 KlassClosure* klass_closure);
0 a61af66fc99e Initial load duke parents: diff changeset	242
a61af66fc99e Initial load duke parents: diff changeset	243 // Apply "blk" to all the weak roots of the system. These include
a61af66fc99e Initial load duke parents: diff changeset	244 // JNI weak roots, the code cache, system dictionary, symbol table,
a61af66fc99e Initial load duke parents: diff changeset	245 // string table.
a61af66fc99e Initial load duke parents: diff changeset	246 void process_weak_roots(OopClosure* root_closure,
10179 a08c80e9e1e5 8012687: Remove unused is_root checks and closures stefank parents: 6725 diff changeset	247 CodeBlobClosure* code_roots);
0 a61af66fc99e Initial load duke parents: diff changeset	248
a61af66fc99e Initial load duke parents: diff changeset	249 // The functions below are helper functions that a subclass of
a61af66fc99e Initial load duke parents: diff changeset	250 // "SharedHeap" can use in the implementation of its virtual
a61af66fc99e Initial load duke parents: diff changeset	251 // functions.
a61af66fc99e Initial load duke parents: diff changeset	252
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	253 public:
0 a61af66fc99e Initial load duke parents: diff changeset	254
a61af66fc99e Initial load duke parents: diff changeset	255 // Do anything common to GC's.
a61af66fc99e Initial load duke parents: diff changeset	256 virtual void gc_prologue(bool full) = 0;
a61af66fc99e Initial load duke parents: diff changeset	257 virtual void gc_epilogue(bool full) = 0;
a61af66fc99e Initial load duke parents: diff changeset	258
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	259 // Sets the number of parallel threads that will be doing tasks
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	260 // (such as process strong roots) subsequently.
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4095 diff changeset	261 virtual void set_par_threads(uint t);
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	262
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	263 int n_termination();
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	264 void set_n_termination(int t);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3293 diff changeset	265
0 a61af66fc99e Initial load duke parents: diff changeset	266 //
a61af66fc99e Initial load duke parents: diff changeset	267 // New methods from CollectedHeap
a61af66fc99e Initial load duke parents: diff changeset	268 //
a61af66fc99e Initial load duke parents: diff changeset	269
a61af66fc99e Initial load duke parents: diff changeset	270 // Some utilities.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	271 void print_size_transition(outputStream* out,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	272 size_t bytes_before,
0 a61af66fc99e Initial load duke parents: diff changeset	273 size_t bytes_after,
a61af66fc99e Initial load duke parents: diff changeset	274 size_t capacity);
a61af66fc99e Initial load duke parents: diff changeset	275 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	276
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	277 #endif // SHARE_VM_MEMORY_SHAREDHEAP_HPP

Mercurial > hg > graal-jvmci-8

annotate src/share/vm/memory/sharedHeap.hpp @ 12233:40136aa2cdb1