codeCache.hpp revision 1564:2a47bd84841f 
1/*
2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25// The CodeCache implements the code cache for various pieces of generated
26// code, e.g., compiled java methods, runtime stubs, transition frames, etc.
27// The entries in the CodeCache are all CodeBlob's.
28
29// Implementation:
30//   - Each CodeBlob occupies one chunk of memory.
31//   - Like the offset table in oldspace the zone has at table for
32//     locating a method given a addess of an instruction.
33
34class OopClosure;
35class DepChange;
36
37class CodeCache : AllStatic {
38  friend class VMStructs;
39 private:
40  // CodeHeap is malloc()'ed at startup and never deleted during shutdown,
41  // so that the generated assembly code is always there when it's needed.
42  // This may cause memory leak, but is necessary, for now. See 4423824,
43  // 4422213 or 4436291 for details.
44  static CodeHeap * _heap;
45  static int _number_of_blobs;
46  static int _number_of_adapters;
47  static int _number_of_nmethods;
48  static int _number_of_nmethods_with_dependencies;
49  static bool _needs_cache_clean;
50  static nmethod* _scavenge_root_nmethods;  // linked via nm->scavenge_root_link()
51  static nmethod* _saved_nmethods;          // linked via nm->saved_nmethod_look()
52
53  static void verify_if_often() PRODUCT_RETURN;
54
55  static void mark_scavenge_root_nmethods() PRODUCT_RETURN;
56  static void verify_perm_nmethods(CodeBlobClosure* f_or_null) PRODUCT_RETURN;
57
58 public:
59
60  // Initialization
61  static void initialize();
62
63  // Allocation/administration
64  static CodeBlob* allocate(int size);              // allocates a new CodeBlob
65  static void commit(CodeBlob* cb);                 // called when the allocated CodeBlob has been filled
66  static int alignment_unit();                      // guaranteed alignment of all CodeBlobs
67  static int alignment_offset();                    // guaranteed offset of first CodeBlob byte within alignment unit (i.e., allocation header)
68  static void free(CodeBlob* cb);                   // frees a CodeBlob
69  static void flush();                              // flushes all CodeBlobs
70  static bool contains(void *p);                    // returns whether p is included
71  static void blobs_do(void f(CodeBlob* cb));       // iterates over all CodeBlobs
72  static void blobs_do(CodeBlobClosure* f);         // iterates over all CodeBlobs
73  static void nmethods_do(void f(nmethod* nm));     // iterates over all nmethods
74
75  // Lookup
76  static CodeBlob* find_blob(void* start);
77  static nmethod*  find_nmethod(void* start);
78
79  // Lookup that does not fail if you lookup a zombie method (if you call this, be sure to know
80  // what you are doing)
81  static CodeBlob* find_blob_unsafe(void* start) {
82    CodeBlob* result = (CodeBlob*)_heap->find_start(start);
83    // this assert is too strong because the heap code will return the
84    // heapblock containing start. That block can often be larger than
85    // the codeBlob itself. If you look up an address that is within
86    // the heapblock but not in the codeBlob you will assert.
87    //
88    // Most things will not lookup such bad addresses. However
89    // AsyncGetCallTrace can see intermediate frames and get that kind
90    // of invalid address and so can a developer using hsfind.
91    //
92    // The more correct answer is to return NULL if blob_contains() returns
93    // false.
94    // assert(result == NULL || result->blob_contains((address)start), "found wrong CodeBlob");
95
96    if (result != NULL && !result->blob_contains((address)start)) {
97      result = NULL;
98    }
99    return result;
100  }
101
102  // Iteration
103  static CodeBlob* first();
104  static CodeBlob* next (CodeBlob* cb);
105  static CodeBlob* alive(CodeBlob *cb);
106  static nmethod* alive_nmethod(CodeBlob *cb);
107  static nmethod* first_nmethod();
108  static nmethod* next_nmethod (CodeBlob* cb);
109  static int       nof_blobs()                 { return _number_of_blobs; }
110  static int       nof_adapters()              { return _number_of_adapters; }
111  static int       nof_nmethods()              { return _number_of_nmethods; }
112
113  // GC support
114  static void gc_epilogue();
115  static void gc_prologue();
116  // If "unloading_occurred" is true, then unloads (i.e., breaks root links
117  // to) any unmarked codeBlobs in the cache.  Sets "marked_for_unloading"
118  // to "true" iff some code got unloaded.
119  static void do_unloading(BoolObjectClosure* is_alive,
120                           OopClosure* keep_alive,
121                           bool unloading_occurred);
122  static void oops_do(OopClosure* f) {
123    CodeBlobToOopClosure oopc(f, /*do_marking=*/ false);
124    blobs_do(&oopc);
125  }
126  static void asserted_non_scavengable_nmethods_do(CodeBlobClosure* f = NULL) PRODUCT_RETURN;
127  static void scavenge_root_nmethods_do(CodeBlobClosure* f);
128
129  static nmethod* scavenge_root_nmethods()          { return _scavenge_root_nmethods; }
130  static void set_scavenge_root_nmethods(nmethod* nm) { _scavenge_root_nmethods = nm; }
131  static void add_scavenge_root_nmethod(nmethod* nm);
132  static void drop_scavenge_root_nmethod(nmethod* nm);
133  static void prune_scavenge_root_nmethods();
134
135  // Printing/debugging
136  static void print()   PRODUCT_RETURN;          // prints summary
137  static void print_internals();
138  static void verify();                          // verifies the code cache
139  static void print_trace(const char* event, CodeBlob* cb, int size = 0) PRODUCT_RETURN;
140
141  // The full limits of the codeCache
142  static address  low_bound()                    { return (address) _heap->low_boundary(); }
143  static address  high_bound()                   { return (address) _heap->high_boundary(); }
144
145  // Profiling
146  static address first_address();                // first address used for CodeBlobs
147  static address last_address();                 // last  address used for CodeBlobs
148  static size_t  capacity()                      { return _heap->capacity(); }
149  static size_t  max_capacity()                  { return _heap->max_capacity(); }
150  static size_t  unallocated_capacity()          { return _heap->unallocated_capacity(); }
151  static bool    needs_flushing()                { return unallocated_capacity() < CodeCacheFlushingMinimumFreeSpace; }
152
153  static bool needs_cache_clean()                { return _needs_cache_clean; }
154  static void set_needs_cache_clean(bool v)      { _needs_cache_clean = v;    }
155  static void clear_inline_caches();             // clear all inline caches
156
157  static nmethod* find_and_remove_saved_code(methodOop m);
158  static void remove_saved_code(nmethod* nm);
159  static void speculatively_disconnect(nmethod* nm);
160
161  // Deoptimization
162  static int  mark_for_deoptimization(DepChange& changes);
163#ifdef HOTSWAP
164  static int  mark_for_evol_deoptimization(instanceKlassHandle dependee);
165#endif // HOTSWAP
166
167  static void mark_all_nmethods_for_deoptimization();
168  static int  mark_for_deoptimization(methodOop dependee);
169  static void make_marked_nmethods_zombies();
170  static void make_marked_nmethods_not_entrant();
171
172    // tells how many nmethods have dependencies
173  static int number_of_nmethods_with_dependencies();
174};
175