src/share/vm/memory/sharedHeap.hpp

Fri, 15 Apr 2011 09:36:28 -0400

author
coleenp
date
Fri, 15 Apr 2011 09:36:28 -0400
changeset 2777
8ce625481709
parent 2314
f95d63e2154a
child 2825
1f4413413144
permissions
-rw-r--r--

7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
Summary: Make CDS reorder vtables so that dump time vtables match run time order, so when redefine classes reinitializes them, they aren't in the wrong order.
Reviewed-by: dcubed, acorn

duke@435 1 /*
jmasa@2188 2 * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
duke@435 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435 4 *
duke@435 5 * This code is free software; you can redistribute it and/or modify it
duke@435 6 * under the terms of the GNU General Public License version 2 only, as
duke@435 7 * published by the Free Software Foundation.
duke@435 8 *
duke@435 9 * This code is distributed in the hope that it will be useful, but WITHOUT
duke@435 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435 12 * version 2 for more details (a copy is included in the LICENSE file that
duke@435 13 * accompanied this code).
duke@435 14 *
duke@435 15 * You should have received a copy of the GNU General Public License version
duke@435 16 * 2 along with this work; if not, write to the Free Software Foundation,
duke@435 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435 18 *
trims@1907 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907 20 * or visit www.oracle.com if you need additional information or have any
trims@1907 21 * questions.
duke@435 22 *
duke@435 23 */
duke@435 24
stefank@2314 25 #ifndef SHARE_VM_MEMORY_SHAREDHEAP_HPP
stefank@2314 26 #define SHARE_VM_MEMORY_SHAREDHEAP_HPP
stefank@2314 27
stefank@2314 28 #include "gc_interface/collectedHeap.hpp"
stefank@2314 29 #include "memory/generation.hpp"
stefank@2314 30 #include "memory/permGen.hpp"
stefank@2314 31
duke@435 32 // A "SharedHeap" is an implementation of a java heap for HotSpot. This
duke@435 33 // is an abstract class: there may be many different kinds of heaps. This
duke@435 34 // class defines the functions that a heap must implement, and contains
duke@435 35 // infrastructure common to all heaps.
duke@435 36
duke@435 37 class PermGen;
duke@435 38 class Generation;
duke@435 39 class BarrierSet;
duke@435 40 class GenRemSet;
duke@435 41 class Space;
duke@435 42 class SpaceClosure;
duke@435 43 class OopClosure;
duke@435 44 class OopsInGenClosure;
duke@435 45 class ObjectClosure;
duke@435 46 class SubTasksDone;
duke@435 47 class WorkGang;
jmasa@2188 48 class FlexibleWorkGang;
duke@435 49 class CollectorPolicy;
duke@435 50 class KlassHandle;
duke@435 51
duke@435 52 class SharedHeap : public CollectedHeap {
duke@435 53 friend class VMStructs;
duke@435 54
ysr@777 55 friend class VM_GC_Operation;
ysr@777 56 friend class VM_CGC_Operation;
ysr@777 57
duke@435 58 private:
duke@435 59 // For claiming strong_roots tasks.
duke@435 60 SubTasksDone* _process_strong_tasks;
duke@435 61
duke@435 62 protected:
duke@435 63 // There should be only a single instance of "SharedHeap" in a program.
duke@435 64 // This is enforced with the protected constructor below, which will also
duke@435 65 // set the static pointer "_sh" to that instance.
duke@435 66 static SharedHeap* _sh;
duke@435 67
duke@435 68 // All heaps contain a "permanent generation." This is some ways
duke@435 69 // similar to a generation in a generational system, in other ways not.
duke@435 70 // See the "PermGen" class.
duke@435 71 PermGen* _perm_gen;
duke@435 72
duke@435 73 // and the Gen Remembered Set, at least one good enough to scan the perm
duke@435 74 // gen.
duke@435 75 GenRemSet* _rem_set;
duke@435 76
duke@435 77 // A gc policy, controls global gc resource issues
duke@435 78 CollectorPolicy *_collector_policy;
duke@435 79
duke@435 80 // See the discussion below, in the specification of the reader function
duke@435 81 // for this variable.
duke@435 82 int _strong_roots_parity;
duke@435 83
duke@435 84 // If we're doing parallel GC, use this gang of threads.
jmasa@2188 85 FlexibleWorkGang* _workers;
duke@435 86
duke@435 87 // Number of parallel threads currently working on GC tasks.
duke@435 88 // O indicates use sequential code; 1 means use parallel code even with
duke@435 89 // only one thread, for performance testing purposes.
duke@435 90 int _n_par_threads;
duke@435 91
duke@435 92 // Full initialization is done in a concrete subtype's "initialize"
duke@435 93 // function.
duke@435 94 SharedHeap(CollectorPolicy* policy_);
duke@435 95
ysr@777 96 // Returns true if the calling thread holds the heap lock,
ysr@777 97 // or the calling thread is a par gc thread and the heap_lock is held
ysr@777 98 // by the vm thread doing a gc operation.
ysr@777 99 bool heap_lock_held_for_gc();
ysr@777 100 // True if the heap_lock is held by the a non-gc thread invoking a gc
ysr@777 101 // operation.
ysr@777 102 bool _thread_holds_heap_lock_for_gc;
ysr@777 103
duke@435 104 public:
duke@435 105 static SharedHeap* heap() { return _sh; }
duke@435 106
duke@435 107 CollectorPolicy *collector_policy() const { return _collector_policy; }
duke@435 108
duke@435 109 void set_barrier_set(BarrierSet* bs);
duke@435 110
duke@435 111 // Does operations required after initialization has been done.
duke@435 112 virtual void post_initialize();
duke@435 113
duke@435 114 // Initialization of ("weak") reference processing support
duke@435 115 virtual void ref_processing_init();
duke@435 116
duke@435 117 void set_perm(PermGen* perm_gen) { _perm_gen = perm_gen; }
duke@435 118
duke@435 119 // This function returns the "GenRemSet" object that allows us to scan
duke@435 120 // generations; at least the perm gen, possibly more in a fully
duke@435 121 // generational heap.
duke@435 122 GenRemSet* rem_set() { return _rem_set; }
duke@435 123
duke@435 124 // These function return the "permanent" generation, in which
duke@435 125 // reflective objects are allocated and stored. Two versions, the second
duke@435 126 // of which returns the view of the perm gen as a generation.
duke@435 127 PermGen* perm() const { return _perm_gen; }
duke@435 128 Generation* perm_gen() const { return _perm_gen->as_gen(); }
duke@435 129
duke@435 130 // Iteration functions.
duke@435 131 void oop_iterate(OopClosure* cl) = 0;
duke@435 132
duke@435 133 // Same as above, restricted to a memory region.
duke@435 134 virtual void oop_iterate(MemRegion mr, OopClosure* cl) = 0;
duke@435 135
duke@435 136 // Iterate over all objects allocated since the last collection, calling
duke@435 137 // "cl->do_object" on each. The heap must have been initialized properly
duke@435 138 // to support this function, or else this call will fail.
duke@435 139 virtual void object_iterate_since_last_GC(ObjectClosure* cl) = 0;
duke@435 140
duke@435 141 // Iterate over all spaces in use in the heap, in an undefined order.
duke@435 142 virtual void space_iterate(SpaceClosure* cl) = 0;
duke@435 143
duke@435 144 // A SharedHeap will contain some number of spaces. This finds the
duke@435 145 // space whose reserved area contains the given address, or else returns
duke@435 146 // NULL.
duke@435 147 virtual Space* space_containing(const void* addr) const = 0;
duke@435 148
duke@435 149 bool no_gc_in_progress() { return !is_gc_active(); }
duke@435 150
duke@435 151 // Some collectors will perform "process_strong_roots" in parallel.
duke@435 152 // Such a call will involve claiming some fine-grained tasks, such as
duke@435 153 // scanning of threads. To make this process simpler, we provide the
duke@435 154 // "strong_roots_parity()" method. Collectors that start parallel tasks
duke@435 155 // whose threads invoke "process_strong_roots" must
duke@435 156 // call "change_strong_roots_parity" in sequential code starting such a
duke@435 157 // task. (This also means that a parallel thread may only call
duke@435 158 // process_strong_roots once.)
duke@435 159 //
duke@435 160 // For calls to process_strong_roots by sequential code, the parity is
duke@435 161 // updated automatically.
duke@435 162 //
duke@435 163 // The idea is that objects representing fine-grained tasks, such as
duke@435 164 // threads, will contain a "parity" field. A task will is claimed in the
duke@435 165 // current "process_strong_roots" call only if its parity field is the
duke@435 166 // same as the "strong_roots_parity"; task claiming is accomplished by
duke@435 167 // updating the parity field to the strong_roots_parity with a CAS.
duke@435 168 //
duke@435 169 // If the client meats this spec, then strong_roots_parity() will have
duke@435 170 // the following properties:
duke@435 171 // a) to return a different value than was returned before the last
duke@435 172 // call to change_strong_roots_parity, and
duke@435 173 // c) to never return a distinguished value (zero) with which such
duke@435 174 // task-claiming variables may be initialized, to indicate "never
duke@435 175 // claimed".
jrose@1424 176 private:
duke@435 177 void change_strong_roots_parity();
jrose@1424 178 public:
duke@435 179 int strong_roots_parity() { return _strong_roots_parity; }
duke@435 180
jrose@1424 181 // Call these in sequential code around process_strong_roots.
jrose@1424 182 // strong_roots_prologue calls change_strong_roots_parity, if
jrose@1424 183 // parallel tasks are enabled.
jrose@1424 184 class StrongRootsScope : public MarkingCodeBlobClosure::MarkScope {
jrose@1424 185 public:
jrose@1424 186 StrongRootsScope(SharedHeap* outer, bool activate = true);
jrose@1424 187 ~StrongRootsScope();
jrose@1424 188 };
jrose@1424 189 friend class StrongRootsScope;
jrose@1424 190
duke@435 191 enum ScanningOption {
duke@435 192 SO_None = 0x0,
duke@435 193 SO_AllClasses = 0x1,
duke@435 194 SO_SystemClasses = 0x2,
duke@435 195 SO_Symbols = 0x4,
duke@435 196 SO_Strings = 0x8,
duke@435 197 SO_CodeCache = 0x10
duke@435 198 };
duke@435 199
jmasa@2188 200 FlexibleWorkGang* workers() const { return _workers; }
duke@435 201
duke@435 202 // Sets the number of parallel threads that will be doing tasks
duke@435 203 // (such as process strong roots) subsequently.
duke@435 204 virtual void set_par_threads(int t);
duke@435 205
duke@435 206 // Number of threads currently working on GC tasks.
duke@435 207 int n_par_threads() { return _n_par_threads; }
duke@435 208
duke@435 209 // Invoke the "do_oop" method the closure "roots" on all root locations.
duke@435 210 // If "collecting_perm_gen" is false, then roots that may only contain
duke@435 211 // references to permGen objects are not scanned. If true, the
duke@435 212 // "perm_gen" closure is applied to all older-to-younger refs in the
duke@435 213 // permanent generation. The "so" argument determines which of roots
duke@435 214 // the closure is applied to:
duke@435 215 // "SO_None" does none;
duke@435 216 // "SO_AllClasses" applies the closure to all entries in the SystemDictionary;
duke@435 217 // "SO_SystemClasses" to all the "system" classes and loaders;
duke@435 218 // "SO_Symbols" applies the closure to all entries in SymbolsTable;
duke@435 219 // "SO_Strings" applies the closure to all entries in StringTable;
duke@435 220 // "SO_CodeCache" applies the closure to all elements of the CodeCache.
jrose@1424 221 void process_strong_roots(bool activate_scope,
jrose@1424 222 bool collecting_perm_gen,
duke@435 223 ScanningOption so,
duke@435 224 OopClosure* roots,
jrose@1424 225 CodeBlobClosure* code_roots,
duke@435 226 OopsInGenClosure* perm_blk);
duke@435 227
duke@435 228 // Apply "blk" to all the weak roots of the system. These include
duke@435 229 // JNI weak roots, the code cache, system dictionary, symbol table,
duke@435 230 // string table.
duke@435 231 void process_weak_roots(OopClosure* root_closure,
jrose@1424 232 CodeBlobClosure* code_roots,
duke@435 233 OopClosure* non_root_closure);
duke@435 234
duke@435 235 // The functions below are helper functions that a subclass of
duke@435 236 // "SharedHeap" can use in the implementation of its virtual
duke@435 237 // functions.
duke@435 238
ysr@777 239 public:
duke@435 240
duke@435 241 // Do anything common to GC's.
duke@435 242 virtual void gc_prologue(bool full) = 0;
duke@435 243 virtual void gc_epilogue(bool full) = 0;
duke@435 244
duke@435 245 //
duke@435 246 // New methods from CollectedHeap
duke@435 247 //
duke@435 248
duke@435 249 size_t permanent_capacity() const {
duke@435 250 assert(perm_gen(), "NULL perm gen");
duke@435 251 return perm_gen()->capacity();
duke@435 252 }
duke@435 253
duke@435 254 size_t permanent_used() const {
duke@435 255 assert(perm_gen(), "NULL perm gen");
duke@435 256 return perm_gen()->used();
duke@435 257 }
duke@435 258
duke@435 259 bool is_in_permanent(const void *p) const {
duke@435 260 assert(perm_gen(), "NULL perm gen");
duke@435 261 return perm_gen()->is_in_reserved(p);
duke@435 262 }
duke@435 263
duke@435 264 // Different from is_in_permanent in that is_in_permanent
duke@435 265 // only checks if p is in the reserved area of the heap
duke@435 266 // and this checks to see if it in the commited area.
duke@435 267 // This is typically used by things like the forte stackwalker
duke@435 268 // during verification of suspicious frame values.
duke@435 269 bool is_permanent(const void *p) const {
duke@435 270 assert(perm_gen(), "NULL perm gen");
duke@435 271 return perm_gen()->is_in(p);
duke@435 272 }
duke@435 273
duke@435 274 HeapWord* permanent_mem_allocate(size_t size) {
duke@435 275 assert(perm_gen(), "NULL perm gen");
duke@435 276 return _perm_gen->mem_allocate(size);
duke@435 277 }
duke@435 278
duke@435 279 void permanent_oop_iterate(OopClosure* cl) {
duke@435 280 assert(perm_gen(), "NULL perm gen");
duke@435 281 _perm_gen->oop_iterate(cl);
duke@435 282 }
duke@435 283
duke@435 284 void permanent_object_iterate(ObjectClosure* cl) {
duke@435 285 assert(perm_gen(), "NULL perm gen");
duke@435 286 _perm_gen->object_iterate(cl);
duke@435 287 }
duke@435 288
duke@435 289 // Some utilities.
ysr@777 290 void print_size_transition(outputStream* out,
ysr@777 291 size_t bytes_before,
duke@435 292 size_t bytes_after,
duke@435 293 size_t capacity);
duke@435 294 };
stefank@2314 295
stefank@2314 296 #endif // SHARE_VM_MEMORY_SHAREDHEAP_HPP

mercurial