graal-compiler: src/share/vm/code/codeCache.hpp annotate

annotate src/share/vm/code/codeCache.hpp @ 3992:d1bdeef3e3e2

7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 Summary: There is a race between one thread successfully forwarding and copying the klass mirror for the SoftReference class (including the static master clock) and another thread attempting to use the master clock while attempting to discover a soft reference object. Maintain a shadow copy of the soft reference master clock and use the shadow during reference discovery and reference processing. Reviewed-by: tonyp, brutisso, ysr

author	johnc
date	Wed, 12 Oct 2011 10:25:51 -0700
parents	6c97c830fb6f
children	d2a62e0f25eb

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
2426 1d1603768966 7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass trims parents: 2375 diff changeset	2 * Copyright (c) 1997, 2011, 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: 1538 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1538 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: 1538 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: 1907 diff changeset	25 #ifndef SHARE_VM_CODE_CODECACHE_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	26 #define SHARE_VM_CODE_CODECACHE_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	28 #include "code/codeBlob.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	29 #include "memory/allocation.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	30 #include "memory/heap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	31 #include "oops/instanceKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	32 #include "oops/oopsHierarchy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	33
0 a61af66fc99e Initial load duke parents: diff changeset	34 // The CodeCache implements the code cache for various pieces of generated
a61af66fc99e Initial load duke parents: diff changeset	35 // code, e.g., compiled java methods, runtime stubs, transition frames, etc.
a61af66fc99e Initial load duke parents: diff changeset	36 // The entries in the CodeCache are all CodeBlob's.
a61af66fc99e Initial load duke parents: diff changeset	37
a61af66fc99e Initial load duke parents: diff changeset	38 // Implementation:
a61af66fc99e Initial load duke parents: diff changeset	39 // - Each CodeBlob occupies one chunk of memory.
a61af66fc99e Initial load duke parents: diff changeset	40 // - Like the offset table in oldspace the zone has at table for
a61af66fc99e Initial load duke parents: diff changeset	41 // locating a method given a addess of an instruction.
a61af66fc99e Initial load duke parents: diff changeset	42
a61af66fc99e Initial load duke parents: diff changeset	43 class OopClosure;
a61af66fc99e Initial load duke parents: diff changeset	44 class DepChange;
a61af66fc99e Initial load duke parents: diff changeset	45
a61af66fc99e Initial load duke parents: diff changeset	46 class CodeCache : AllStatic {
a61af66fc99e Initial load duke parents: diff changeset	47 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	48 private:
a61af66fc99e Initial load duke parents: diff changeset	49 // CodeHeap is malloc()'ed at startup and never deleted during shutdown,
a61af66fc99e Initial load duke parents: diff changeset	50 // so that the generated assembly code is always there when it's needed.
a61af66fc99e Initial load duke parents: diff changeset	51 // This may cause memory leak, but is necessary, for now. See 4423824,
a61af66fc99e Initial load duke parents: diff changeset	52 // 4422213 or 4436291 for details.
a61af66fc99e Initial load duke parents: diff changeset	53 static CodeHeap * _heap;
a61af66fc99e Initial load duke parents: diff changeset	54 static int _number_of_blobs;
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1552 diff changeset	55 static int _number_of_adapters;
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1552 diff changeset	56 static int _number_of_nmethods;
0 a61af66fc99e Initial load duke parents: diff changeset	57 static int _number_of_nmethods_with_dependencies;
a61af66fc99e Initial load duke parents: diff changeset	58 static bool _needs_cache_clean;
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	59 static nmethod* _scavenge_root_nmethods; // linked via nm->scavenge_root_link()
1202 5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 989 diff changeset	60 static nmethod* _saved_nmethods; // linked via nm->saved_nmethod_look()
0 a61af66fc99e Initial load duke parents: diff changeset	61
a61af66fc99e Initial load duke parents: diff changeset	62 static void verify_if_often() PRODUCT_RETURN;
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	63
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	64 static void mark_scavenge_root_nmethods() PRODUCT_RETURN;
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	65 static void verify_perm_nmethods(CodeBlobClosure* f_or_null) PRODUCT_RETURN;
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	66
0 a61af66fc99e Initial load duke parents: diff changeset	67 public:
a61af66fc99e Initial load duke parents: diff changeset	68
a61af66fc99e Initial load duke parents: diff changeset	69 // Initialization
a61af66fc99e Initial load duke parents: diff changeset	70 static void initialize();
a61af66fc99e Initial load duke parents: diff changeset	71
a61af66fc99e Initial load duke parents: diff changeset	72 // Allocation/administration
a61af66fc99e Initial load duke parents: diff changeset	73 static CodeBlob* allocate(int size); // allocates a new CodeBlob
a61af66fc99e Initial load duke parents: diff changeset	74 static void commit(CodeBlob* cb); // called when the allocated CodeBlob has been filled
a61af66fc99e Initial load duke parents: diff changeset	75 static int alignment_unit(); // guaranteed alignment of all CodeBlobs
a61af66fc99e Initial load duke parents: diff changeset	76 static int alignment_offset(); // guaranteed offset of first CodeBlob byte within alignment unit (i.e., allocation header)
a61af66fc99e Initial load duke parents: diff changeset	77 static void free(CodeBlob* cb); // frees a CodeBlob
a61af66fc99e Initial load duke parents: diff changeset	78 static void flush(); // flushes all CodeBlobs
a61af66fc99e Initial load duke parents: diff changeset	79 static bool contains(void *p); // returns whether p is included
a61af66fc99e Initial load duke parents: diff changeset	80 static void blobs_do(void f(CodeBlob* cb)); // iterates over all CodeBlobs
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	81 static void blobs_do(CodeBlobClosure* f); // iterates over all CodeBlobs
0 a61af66fc99e Initial load duke parents: diff changeset	82 static void nmethods_do(void f(nmethod* nm)); // iterates over all nmethods
a61af66fc99e Initial load duke parents: diff changeset	83
a61af66fc99e Initial load duke parents: diff changeset	84 // Lookup
a61af66fc99e Initial load duke parents: diff changeset	85 static CodeBlob* find_blob(void* start);
a61af66fc99e Initial load duke parents: diff changeset	86 static nmethod* find_nmethod(void* start);
a61af66fc99e Initial load duke parents: diff changeset	87
a61af66fc99e Initial load duke parents: diff changeset	88 // Lookup that does not fail if you lookup a zombie method (if you call this, be sure to know
a61af66fc99e Initial load duke parents: diff changeset	89 // what you are doing)
a61af66fc99e Initial load duke parents: diff changeset	90 static CodeBlob* find_blob_unsafe(void* start) {
a61af66fc99e Initial load duke parents: diff changeset	91 CodeBlob* result = (CodeBlob*)_heap->find_start(start);
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	92 // this assert is too strong because the heap code will return the
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	93 // heapblock containing start. That block can often be larger than
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	94 // the codeBlob itself. If you look up an address that is within
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	95 // the heapblock but not in the codeBlob you will assert.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	96 //
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	97 // Most things will not lookup such bad addresses. However
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	98 // AsyncGetCallTrace can see intermediate frames and get that kind
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	99 // of invalid address and so can a developer using hsfind.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	100 //
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	101 // The more correct answer is to return NULL if blob_contains() returns
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	102 // false.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	103 // assert(result == NULL \|\| result->blob_contains((address)start), "found wrong CodeBlob");
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	104
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	105 if (result != NULL && !result->blob_contains((address)start)) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	106 result = NULL;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	107 }
0 a61af66fc99e Initial load duke parents: diff changeset	108 return result;
a61af66fc99e Initial load duke parents: diff changeset	109 }
a61af66fc99e Initial load duke parents: diff changeset	110
a61af66fc99e Initial load duke parents: diff changeset	111 // Iteration
a61af66fc99e Initial load duke parents: diff changeset	112 static CodeBlob* first();
a61af66fc99e Initial load duke parents: diff changeset	113 static CodeBlob* next (CodeBlob* cb);
a61af66fc99e Initial load duke parents: diff changeset	114 static CodeBlob* alive(CodeBlob *cb);
a61af66fc99e Initial load duke parents: diff changeset	115 static nmethod* alive_nmethod(CodeBlob *cb);
1538 bfe29ec02863 6950075: nmethod sweeper should operate concurrently never parents: 1202 diff changeset	116 static nmethod* first_nmethod();
bfe29ec02863 6950075: nmethod sweeper should operate concurrently never parents: 1202 diff changeset	117 static nmethod* next_nmethod (CodeBlob* cb);
0 a61af66fc99e Initial load duke parents: diff changeset	118 static int nof_blobs() { return _number_of_blobs; }
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1552 diff changeset	119 static int nof_adapters() { return _number_of_adapters; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1552 diff changeset	120 static int nof_nmethods() { return _number_of_nmethods; }
0 a61af66fc99e Initial load duke parents: diff changeset	121
a61af66fc99e Initial load duke parents: diff changeset	122 // GC support
a61af66fc99e Initial load duke parents: diff changeset	123 static void gc_epilogue();
a61af66fc99e Initial load duke parents: diff changeset	124 static void gc_prologue();
2375 d673ef06fe96 7028374: race in fix_oop_relocations for scavengeable nmethods never parents: 2353 diff changeset	125 static void verify_oops();
0 a61af66fc99e Initial load duke parents: diff changeset	126 // If "unloading_occurred" is true, then unloads (i.e., breaks root links
a61af66fc99e Initial load duke parents: diff changeset	127 // to) any unmarked codeBlobs in the cache. Sets "marked_for_unloading"
a61af66fc99e Initial load duke parents: diff changeset	128 // to "true" iff some code got unloaded.
a61af66fc99e Initial load duke parents: diff changeset	129 static void do_unloading(BoolObjectClosure* is_alive,
a61af66fc99e Initial load duke parents: diff changeset	130 OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	131 bool unloading_occurred);
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	132 static void oops_do(OopClosure* f) {
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	133 CodeBlobToOopClosure oopc(f, /do_marking=/ false);
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	134 blobs_do(&oopc);
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	135 }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	136 static void asserted_non_scavengable_nmethods_do(CodeBlobClosure* f = NULL) PRODUCT_RETURN;
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	137 static void scavenge_root_nmethods_do(CodeBlobClosure* f);
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	138
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	139 static nmethod* scavenge_root_nmethods() { return _scavenge_root_nmethods; }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	140 static void set_scavenge_root_nmethods(nmethod* nm) { _scavenge_root_nmethods = nm; }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	141 static void add_scavenge_root_nmethod(nmethod* nm);
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	142 static void drop_scavenge_root_nmethod(nmethod* nm);
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	143 static void prune_scavenge_root_nmethods();
0 a61af66fc99e Initial load duke parents: diff changeset	144
a61af66fc99e Initial load duke parents: diff changeset	145 // Printing/debugging
a61af66fc99e Initial load duke parents: diff changeset	146 static void print() PRODUCT_RETURN; // prints summary
a61af66fc99e Initial load duke parents: diff changeset	147 static void print_internals();
a61af66fc99e Initial load duke parents: diff changeset	148 static void verify(); // verifies the code cache
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	149 static void print_trace(const char* event, CodeBlob* cb, int size = 0) PRODUCT_RETURN;
1907 1e9a9d2e6509 6970683: improvements to hs_err output never parents: 1644 diff changeset	150 static void print_bounds(outputStream* st); // Prints a summary of the bounds of the code cache
2353 1c0cf339481b 7025742: Can not use CodeCache::unallocated_capacity() with fragmented CodeCache kvn parents: 2091 diff changeset	151 static void log_state(outputStream* st);
0 a61af66fc99e Initial load duke parents: diff changeset	152
a61af66fc99e Initial load duke parents: diff changeset	153 // The full limits of the codeCache
a61af66fc99e Initial load duke parents: diff changeset	154 static address low_bound() { return (address) _heap->low_boundary(); }
a61af66fc99e Initial load duke parents: diff changeset	155 static address high_bound() { return (address) _heap->high_boundary(); }
a61af66fc99e Initial load duke parents: diff changeset	156
a61af66fc99e Initial load duke parents: diff changeset	157 // Profiling
a61af66fc99e Initial load duke parents: diff changeset	158 static address first_address(); // first address used for CodeBlobs
a61af66fc99e Initial load duke parents: diff changeset	159 static address last_address(); // last address used for CodeBlobs
a61af66fc99e Initial load duke parents: diff changeset	160 static size_t capacity() { return _heap->capacity(); }
a61af66fc99e Initial load duke parents: diff changeset	161 static size_t max_capacity() { return _heap->max_capacity(); }
a61af66fc99e Initial load duke parents: diff changeset	162 static size_t unallocated_capacity() { return _heap->unallocated_capacity(); }
2457 527977d4f740 7033779: CodeCache::largest_free_block may need to hold the CodeCache lock never parents: 2375 diff changeset	163 static size_t largest_free_block();
2353 1c0cf339481b 7025742: Can not use CodeCache::unallocated_capacity() with fragmented CodeCache kvn parents: 2091 diff changeset	164 static bool needs_flushing() { return largest_free_block() < CodeCacheFlushingMinimumFreeSpace; }
0 a61af66fc99e Initial load duke parents: diff changeset	165
a61af66fc99e Initial load duke parents: diff changeset	166 static bool needs_cache_clean() { return _needs_cache_clean; }
a61af66fc99e Initial load duke parents: diff changeset	167 static void set_needs_cache_clean(bool v) { _needs_cache_clean = v; }
a61af66fc99e Initial load duke parents: diff changeset	168 static void clear_inline_caches(); // clear all inline caches
a61af66fc99e Initial load duke parents: diff changeset	169
1202 5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 989 diff changeset	170 static nmethod* find_and_remove_saved_code(methodOop m);
5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 989 diff changeset	171 static void remove_saved_code(nmethod* nm);
5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 989 diff changeset	172 static void speculatively_disconnect(nmethod* nm);
5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 989 diff changeset	173
0 a61af66fc99e Initial load duke parents: diff changeset	174 // Deoptimization
a61af66fc99e Initial load duke parents: diff changeset	175 static int mark_for_deoptimization(DepChange& changes);
a61af66fc99e Initial load duke parents: diff changeset	176 #ifdef HOTSWAP
a61af66fc99e Initial load duke parents: diff changeset	177 static int mark_for_evol_deoptimization(instanceKlassHandle dependee);
a61af66fc99e Initial load duke parents: diff changeset	178 #endif // HOTSWAP
a61af66fc99e Initial load duke parents: diff changeset	179
a61af66fc99e Initial load duke parents: diff changeset	180 static void mark_all_nmethods_for_deoptimization();
a61af66fc99e Initial load duke parents: diff changeset	181 static int mark_for_deoptimization(methodOop dependee);
a61af66fc99e Initial load duke parents: diff changeset	182 static void make_marked_nmethods_zombies();
a61af66fc99e Initial load duke parents: diff changeset	183 static void make_marked_nmethods_not_entrant();
a61af66fc99e Initial load duke parents: diff changeset	184
a61af66fc99e Initial load duke parents: diff changeset	185 // tells how many nmethods have dependencies
a61af66fc99e Initial load duke parents: diff changeset	186 static int number_of_nmethods_with_dependencies();
a61af66fc99e Initial load duke parents: diff changeset	187 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	188
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	189 #endif // SHARE_VM_CODE_CODECACHE_HPP

Mercurial > hg > graal-compiler

annotate src/share/vm/code/codeCache.hpp @ 3992:d1bdeef3e3e2