Mercurial > hg > graal-jvmci-8
diff src/share/vm/code/codeCache.hpp @ 0:a61af66fc99e jdk7-b24
Initial load
author | duke |
---|---|
date | Sat, 01 Dec 2007 00:00:00 +0000 |
parents | |
children | 93b6525e3b82 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/code/codeCache.hpp Sat Dec 01 00:00:00 2007 +0000 @@ -0,0 +1,129 @@ +/* + * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +// The CodeCache implements the code cache for various pieces of generated +// code, e.g., compiled java methods, runtime stubs, transition frames, etc. +// The entries in the CodeCache are all CodeBlob's. + +// Implementation: +// - Each CodeBlob occupies one chunk of memory. +// - Like the offset table in oldspace the zone has at table for +// locating a method given a addess of an instruction. + +class OopClosure; +class DepChange; + +class CodeCache : AllStatic { + friend class VMStructs; + private: + // CodeHeap is malloc()'ed at startup and never deleted during shutdown, + // so that the generated assembly code is always there when it's needed. + // This may cause memory leak, but is necessary, for now. See 4423824, + // 4422213 or 4436291 for details. + static CodeHeap * _heap; + static int _number_of_blobs; + static int _number_of_nmethods_with_dependencies; + static bool _needs_cache_clean; + + static void verify_if_often() PRODUCT_RETURN; + public: + + // Initialization + static void initialize(); + + // Allocation/administration + static CodeBlob* allocate(int size); // allocates a new CodeBlob + static void commit(CodeBlob* cb); // called when the allocated CodeBlob has been filled + static int alignment_unit(); // guaranteed alignment of all CodeBlobs + static int alignment_offset(); // guaranteed offset of first CodeBlob byte within alignment unit (i.e., allocation header) + static void free(CodeBlob* cb); // frees a CodeBlob + static void flush(); // flushes all CodeBlobs + static bool contains(void *p); // returns whether p is included + static void blobs_do(void f(CodeBlob* cb)); // iterates over all CodeBlobs + static void nmethods_do(void f(nmethod* nm)); // iterates over all nmethods + + // Lookup + static CodeBlob* find_blob(void* start); + static nmethod* find_nmethod(void* start); + + // Lookup that does not fail if you lookup a zombie method (if you call this, be sure to know + // what you are doing) + static CodeBlob* find_blob_unsafe(void* start) { + CodeBlob* result = (CodeBlob*)_heap->find_start(start); + assert(result == NULL || result->blob_contains((address)start), "found wrong CodeBlob"); + return result; + } + + // Iteration + static CodeBlob* first(); + static CodeBlob* next (CodeBlob* cb); + static CodeBlob* alive(CodeBlob *cb); + static nmethod* alive_nmethod(CodeBlob *cb); + static int nof_blobs() { return _number_of_blobs; } + + // GC support + static void gc_epilogue(); + static void gc_prologue(); + // If "unloading_occurred" is true, then unloads (i.e., breaks root links + // to) any unmarked codeBlobs in the cache. Sets "marked_for_unloading" + // to "true" iff some code got unloaded. + static void do_unloading(BoolObjectClosure* is_alive, + OopClosure* keep_alive, + bool unloading_occurred); + static void oops_do(OopClosure* f); + + // Printing/debugging + static void print() PRODUCT_RETURN; // prints summary + static void print_internals(); + static void verify(); // verifies the code cache + + // The full limits of the codeCache + static address low_bound() { return (address) _heap->low_boundary(); } + static address high_bound() { return (address) _heap->high_boundary(); } + + // Profiling + static address first_address(); // first address used for CodeBlobs + static address last_address(); // last address used for CodeBlobs + static size_t capacity() { return _heap->capacity(); } + static size_t max_capacity() { return _heap->max_capacity(); } + static size_t unallocated_capacity() { return _heap->unallocated_capacity(); } + + static bool needs_cache_clean() { return _needs_cache_clean; } + static void set_needs_cache_clean(bool v) { _needs_cache_clean = v; } + static void clear_inline_caches(); // clear all inline caches + + // Deoptimization + static int mark_for_deoptimization(DepChange& changes); +#ifdef HOTSWAP + static int mark_for_evol_deoptimization(instanceKlassHandle dependee); +#endif // HOTSWAP + + static void mark_all_nmethods_for_deoptimization(); + static int mark_for_deoptimization(methodOop dependee); + static void make_marked_nmethods_zombies(); + static void make_marked_nmethods_not_entrant(); + + // tells how many nmethods have dependencies + static int number_of_nmethods_with_dependencies(); +};