truffle: src/share/vm/code/codeCache.hpp annotate

annotate src/share/vm/code/codeCache.hpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso

author	tschatzl
date	Fri, 10 Oct 2014 15:51:58 +0200
parents	2c6ef90f030a
children	7848fc12602b

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	2 * Copyright (c) 1997, 2013, 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()
0 a61af66fc99e Initial load duke parents: diff changeset	60
a61af66fc99e Initial load duke parents: diff changeset	61 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	62
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	63 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	64 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	65
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	66 static int _codemem_full_count;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	67
0 a61af66fc99e Initial load duke parents: diff changeset	68 public:
a61af66fc99e Initial load duke parents: diff changeset	69
a61af66fc99e Initial load duke parents: diff changeset	70 // Initialization
a61af66fc99e Initial load duke parents: diff changeset	71 static void initialize();
a61af66fc99e Initial load duke parents: diff changeset	72
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	73 static void report_codemem_full();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	74
0 a61af66fc99e Initial load duke parents: diff changeset	75 // Allocation/administration
10114 a7fb14888912 8006952: Slow VM due to excessive code cache freelist iteration neliasso parents: 8864 diff changeset	76 static CodeBlob* allocate(int size, bool is_critical = false); // allocates a new CodeBlob
0 a61af66fc99e Initial load duke parents: diff changeset	77 static void commit(CodeBlob* cb); // called when the allocated CodeBlob has been filled
a61af66fc99e Initial load duke parents: diff changeset	78 static int alignment_unit(); // guaranteed alignment of all CodeBlobs
a61af66fc99e Initial load duke parents: diff changeset	79 static int alignment_offset(); // guaranteed offset of first CodeBlob byte within alignment unit (i.e., allocation header)
a61af66fc99e Initial load duke parents: diff changeset	80 static void free(CodeBlob* cb); // frees a CodeBlob
a61af66fc99e Initial load duke parents: diff changeset	81 static void flush(); // flushes all CodeBlobs
a61af66fc99e Initial load duke parents: diff changeset	82 static bool contains(void *p); // returns whether p is included
a61af66fc99e Initial load duke parents: diff changeset	83 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	84 static void blobs_do(CodeBlobClosure* f); // iterates over all CodeBlobs
0 a61af66fc99e Initial load duke parents: diff changeset	85 static void nmethods_do(void f(nmethod* nm)); // iterates over all nmethods
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	86 static void alive_nmethods_do(void f(nmethod* nm)); // iterates over all alive nmethods
0 a61af66fc99e Initial load duke parents: diff changeset	87
a61af66fc99e Initial load duke parents: diff changeset	88 // Lookup
a61af66fc99e Initial load duke parents: diff changeset	89 static CodeBlob* find_blob(void* start);
a61af66fc99e Initial load duke parents: diff changeset	90 static nmethod* find_nmethod(void* start);
a61af66fc99e Initial load duke parents: diff changeset	91
a61af66fc99e Initial load duke parents: diff changeset	92 // 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	93 // what you are doing)
a61af66fc99e Initial load duke parents: diff changeset	94 static CodeBlob* find_blob_unsafe(void* start) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 2468 diff changeset	95 // NMT can walk the stack before code cache is created
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 2468 diff changeset	96 if (_heap == NULL) return NULL;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 2468 diff changeset	97
0 a61af66fc99e Initial load duke parents: diff changeset	98 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	99 // 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	100 // 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	101 // 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	102 // 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	103 //
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	104 // 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	105 // 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	106 // 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	107 //
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	108 // 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	109 // false.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	110 // 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	111
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	112 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	113 result = NULL;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	114 }
0 a61af66fc99e Initial load duke parents: diff changeset	115 return result;
a61af66fc99e Initial load duke parents: diff changeset	116 }
a61af66fc99e Initial load duke parents: diff changeset	117
a61af66fc99e Initial load duke parents: diff changeset	118 // Iteration
a61af66fc99e Initial load duke parents: diff changeset	119 static CodeBlob* first();
a61af66fc99e Initial load duke parents: diff changeset	120 static CodeBlob* next (CodeBlob* cb);
a61af66fc99e Initial load duke parents: diff changeset	121 static CodeBlob* alive(CodeBlob *cb);
a61af66fc99e Initial load duke parents: diff changeset	122 static nmethod* alive_nmethod(CodeBlob *cb);
1538 bfe29ec02863 6950075: nmethod sweeper should operate concurrently never parents: 1202 diff changeset	123 static nmethod* first_nmethod();
bfe29ec02863 6950075: nmethod sweeper should operate concurrently never parents: 1202 diff changeset	124 static nmethod* next_nmethod (CodeBlob* cb);
0 a61af66fc99e Initial load duke parents: diff changeset	125 static int nof_blobs() { return _number_of_blobs; }
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1552 diff changeset	126 static int nof_adapters() { return _number_of_adapters; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1552 diff changeset	127 static int nof_nmethods() { return _number_of_nmethods; }
0 a61af66fc99e Initial load duke parents: diff changeset	128
a61af66fc99e Initial load duke parents: diff changeset	129 // GC support
a61af66fc99e Initial load duke parents: diff changeset	130 static void gc_epilogue();
a61af66fc99e Initial load duke parents: diff changeset	131 static void gc_prologue();
2375 d673ef06fe96 7028374: race in fix_oop_relocations for scavengeable nmethods never parents: 2353 diff changeset	132 static void verify_oops();
0 a61af66fc99e Initial load duke parents: diff changeset	133 // If "unloading_occurred" is true, then unloads (i.e., breaks root links
a61af66fc99e Initial load duke parents: diff changeset	134 // to) any unmarked codeBlobs in the cache. Sets "marked_for_unloading"
a61af66fc99e Initial load duke parents: diff changeset	135 // to "true" iff some code got unloaded.
6787 8966c2d65d96 7200470: KeepAliveClosure not needed in CodeCache::do_unloading brutisso parents: 6725 diff changeset	136 static void do_unloading(BoolObjectClosure* is_alive, bool unloading_occurred);
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	137 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	138 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	139
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	140 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	141 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	142 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	143 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	144 static void prune_scavenge_root_nmethods();
0 a61af66fc99e Initial load duke parents: diff changeset	145
a61af66fc99e Initial load duke parents: diff changeset	146 // Printing/debugging
7595 9deda4d8e126 8005204: Code Cache Reduction: command line options implementation vladidan parents: 6787 diff changeset	147 static void print(); // prints summary
0 a61af66fc99e Initial load duke parents: diff changeset	148 static void print_internals();
a61af66fc99e Initial load duke parents: diff changeset	149 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	150 static void print_trace(const char* event, CodeBlob* cb, int size = 0) PRODUCT_RETURN;
7595 9deda4d8e126 8005204: Code Cache Reduction: command line options implementation vladidan parents: 6787 diff changeset	151 static void print_summary(outputStream* st, bool detailed = true); // Prints a summary of the code cache usage
2353 1c0cf339481b 7025742: Can not use CodeCache::unallocated_capacity() with fragmented CodeCache kvn parents: 2091 diff changeset	152 static void log_state(outputStream* st);
0 a61af66fc99e Initial load duke parents: diff changeset	153
a61af66fc99e Initial load duke parents: diff changeset	154 // The full limits of the codeCache
a61af66fc99e Initial load duke parents: diff changeset	155 static address low_bound() { return (address) _heap->low_boundary(); }
a61af66fc99e Initial load duke parents: diff changeset	156 static address high_bound() { return (address) _heap->high_boundary(); }
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	157 static address high() { return (address) _heap->high(); }
0 a61af66fc99e Initial load duke parents: diff changeset	158
a61af66fc99e Initial load duke parents: diff changeset	159 // Profiling
a61af66fc99e Initial load duke parents: diff changeset	160 static address first_address(); // first address used for CodeBlobs
a61af66fc99e Initial load duke parents: diff changeset	161 static address last_address(); // last address used for CodeBlobs
a61af66fc99e Initial load duke parents: diff changeset	162 static size_t capacity() { return _heap->capacity(); }
a61af66fc99e Initial load duke parents: diff changeset	163 static size_t max_capacity() { return _heap->max_capacity(); }
a61af66fc99e Initial load duke parents: diff changeset	164 static size_t unallocated_capacity() { return _heap->unallocated_capacity(); }
10319 91eba9f82325 8012371: Adjust Tiered compile threshold according to available space in code cache anoll parents: 10206 diff changeset	165 static double reverse_free_ratio();
0 a61af66fc99e Initial load duke parents: diff changeset	166
a61af66fc99e Initial load duke parents: diff changeset	167 static bool needs_cache_clean() { return _needs_cache_clean; }
a61af66fc99e Initial load duke parents: diff changeset	168 static void set_needs_cache_clean(bool v) { _needs_cache_clean = v; }
a61af66fc99e Initial load duke parents: diff changeset	169 static void clear_inline_caches(); // clear all inline caches
a61af66fc99e Initial load duke parents: diff changeset	170
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 12324 diff changeset	171 static void verify_clean_inline_caches();
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 12324 diff changeset	172 static void verify_icholder_relocations();
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 12324 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();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	181 static int mark_for_deoptimization(Method* dependee);
0 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();
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	187
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10319 diff changeset	188 static int get_codemem_full_count() { return _codemem_full_count; }
0 a61af66fc99e Initial load duke parents: diff changeset	189 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	190
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	191 #endif // SHARE_VM_CODE_CODECACHE_HPP

Mercurial > hg > truffle

annotate src/share/vm/code/codeCache.hpp @ 20543:e7d0505c8a30