annotate src/share/vm/memory/resourceArea.hpp @ 3939:f6f3bb0ee072

7088955: add C2 IR support to the SA Reviewed-by: kvn
author never
date Sun, 11 Sep 2011 14:48:24 -0700
parents f95d63e2154a
children f08d439fab8c
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
3939
f6f3bb0ee072 7088955: add C2 IR support to the SA
never
parents: 1972
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: 0
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 0
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: 0
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: 1552
diff changeset
25 #ifndef SHARE_VM_MEMORY_RESOURCEAREA_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
26 #define SHARE_VM_MEMORY_RESOURCEAREA_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
27
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
28 #include "memory/allocation.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
29 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
30 # include "thread_linux.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
31 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
32 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
33 # include "thread_solaris.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
34 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
35 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
36 # include "thread_windows.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
37 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
38
0
a61af66fc99e Initial load
duke
parents:
diff changeset
39 // The resource area holds temporary data structures in the VM.
a61af66fc99e Initial load
duke
parents:
diff changeset
40 // The actual allocation areas are thread local. Typical usage:
a61af66fc99e Initial load
duke
parents:
diff changeset
41 //
a61af66fc99e Initial load
duke
parents:
diff changeset
42 // ...
a61af66fc99e Initial load
duke
parents:
diff changeset
43 // {
a61af66fc99e Initial load
duke
parents:
diff changeset
44 // ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
45 // int foo[] = NEW_RESOURCE_ARRAY(int, 64);
a61af66fc99e Initial load
duke
parents:
diff changeset
46 // ...
a61af66fc99e Initial load
duke
parents:
diff changeset
47 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
48 // ...
a61af66fc99e Initial load
duke
parents:
diff changeset
49
a61af66fc99e Initial load
duke
parents:
diff changeset
50 //------------------------------ResourceArea-----------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
51 // A ResourceArea is an Arena that supports safe usage of ResourceMark.
a61af66fc99e Initial load
duke
parents:
diff changeset
52 class ResourceArea: public Arena {
a61af66fc99e Initial load
duke
parents:
diff changeset
53 friend class ResourceMark;
a61af66fc99e Initial load
duke
parents:
diff changeset
54 friend class DeoptResourceMark;
3939
f6f3bb0ee072 7088955: add C2 IR support to the SA
never
parents: 1972
diff changeset
55 friend class VMStructs;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
56 debug_only(int _nesting;) // current # of nested ResourceMarks
a61af66fc99e Initial load
duke
parents:
diff changeset
57 debug_only(static int _warned;) // to suppress multiple warnings
a61af66fc99e Initial load
duke
parents:
diff changeset
58
a61af66fc99e Initial load
duke
parents:
diff changeset
59 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
60 ResourceArea() {
a61af66fc99e Initial load
duke
parents:
diff changeset
61 debug_only(_nesting = 0;)
a61af66fc99e Initial load
duke
parents:
diff changeset
62 }
a61af66fc99e Initial load
duke
parents:
diff changeset
63
a61af66fc99e Initial load
duke
parents:
diff changeset
64 ResourceArea(size_t init_size) : Arena(init_size) {
a61af66fc99e Initial load
duke
parents:
diff changeset
65 debug_only(_nesting = 0;);
a61af66fc99e Initial load
duke
parents:
diff changeset
66 }
a61af66fc99e Initial load
duke
parents:
diff changeset
67
a61af66fc99e Initial load
duke
parents:
diff changeset
68 char* allocate_bytes(size_t size) {
a61af66fc99e Initial load
duke
parents:
diff changeset
69 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
70 if (_nesting < 1 && !_warned++)
a61af66fc99e Initial load
duke
parents:
diff changeset
71 fatal("memory leak: allocating without ResourceMark");
a61af66fc99e Initial load
duke
parents:
diff changeset
72 if (UseMallocOnly) {
a61af66fc99e Initial load
duke
parents:
diff changeset
73 // use malloc, but save pointer in res. area for later freeing
a61af66fc99e Initial load
duke
parents:
diff changeset
74 char** save = (char**)internal_malloc_4(sizeof(char*));
a61af66fc99e Initial load
duke
parents:
diff changeset
75 return (*save = (char*)os::malloc(size));
a61af66fc99e Initial load
duke
parents:
diff changeset
76 }
a61af66fc99e Initial load
duke
parents:
diff changeset
77 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
78 return (char*)Amalloc(size);
a61af66fc99e Initial load
duke
parents:
diff changeset
79 }
a61af66fc99e Initial load
duke
parents:
diff changeset
80
a61af66fc99e Initial load
duke
parents:
diff changeset
81 debug_only(int nesting() const { return _nesting; });
a61af66fc99e Initial load
duke
parents:
diff changeset
82 };
a61af66fc99e Initial load
duke
parents:
diff changeset
83
a61af66fc99e Initial load
duke
parents:
diff changeset
84
a61af66fc99e Initial load
duke
parents:
diff changeset
85 //------------------------------ResourceMark-----------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
86 // A resource mark releases all resources allocated after it was constructed
a61af66fc99e Initial load
duke
parents:
diff changeset
87 // when the destructor is called. Typically used as a local variable.
a61af66fc99e Initial load
duke
parents:
diff changeset
88 class ResourceMark: public StackObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
89 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
90 ResourceArea *_area; // Resource area to stack allocate
a61af66fc99e Initial load
duke
parents:
diff changeset
91 Chunk *_chunk; // saved arena chunk
a61af66fc99e Initial load
duke
parents:
diff changeset
92 char *_hwm, *_max;
a61af66fc99e Initial load
duke
parents:
diff changeset
93 NOT_PRODUCT(size_t _size_in_bytes;)
a61af66fc99e Initial load
duke
parents:
diff changeset
94
a61af66fc99e Initial load
duke
parents:
diff changeset
95 void initialize(Thread *thread) {
a61af66fc99e Initial load
duke
parents:
diff changeset
96 _area = thread->resource_area();
a61af66fc99e Initial load
duke
parents:
diff changeset
97 _chunk = _area->_chunk;
a61af66fc99e Initial load
duke
parents:
diff changeset
98 _hwm = _area->_hwm;
a61af66fc99e Initial load
duke
parents:
diff changeset
99 _max= _area->_max;
a61af66fc99e Initial load
duke
parents:
diff changeset
100 NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();)
a61af66fc99e Initial load
duke
parents:
diff changeset
101 debug_only(_area->_nesting++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
102 assert( _area->_nesting > 0, "must stack allocate RMs" );
a61af66fc99e Initial load
duke
parents:
diff changeset
103 }
a61af66fc99e Initial load
duke
parents:
diff changeset
104
a61af66fc99e Initial load
duke
parents:
diff changeset
105 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
106
a61af66fc99e Initial load
duke
parents:
diff changeset
107 #ifndef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
108 ResourceMark(Thread *thread) {
a61af66fc99e Initial load
duke
parents:
diff changeset
109 assert(thread == Thread::current(), "not the current thread");
a61af66fc99e Initial load
duke
parents:
diff changeset
110 initialize(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
111 }
a61af66fc99e Initial load
duke
parents:
diff changeset
112 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
113 ResourceMark(Thread *thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
114 #endif // ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
115
a61af66fc99e Initial load
duke
parents:
diff changeset
116 ResourceMark() { initialize(Thread::current()); }
a61af66fc99e Initial load
duke
parents:
diff changeset
117
a61af66fc99e Initial load
duke
parents:
diff changeset
118 ResourceMark( ResourceArea *r ) :
a61af66fc99e Initial load
duke
parents:
diff changeset
119 _area(r), _chunk(r->_chunk), _hwm(r->_hwm), _max(r->_max) {
a61af66fc99e Initial load
duke
parents:
diff changeset
120 NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();)
a61af66fc99e Initial load
duke
parents:
diff changeset
121 debug_only(_area->_nesting++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
122 assert( _area->_nesting > 0, "must stack allocate RMs" );
a61af66fc99e Initial load
duke
parents:
diff changeset
123 }
a61af66fc99e Initial load
duke
parents:
diff changeset
124
a61af66fc99e Initial load
duke
parents:
diff changeset
125 void reset_to_mark() {
a61af66fc99e Initial load
duke
parents:
diff changeset
126 if (UseMallocOnly) free_malloced_objects();
a61af66fc99e Initial load
duke
parents:
diff changeset
127
a61af66fc99e Initial load
duke
parents:
diff changeset
128 if( _chunk->next() ) // Delete later chunks
a61af66fc99e Initial load
duke
parents:
diff changeset
129 _chunk->next_chop();
a61af66fc99e Initial load
duke
parents:
diff changeset
130 _area->_chunk = _chunk; // Roll back arena to saved chunk
a61af66fc99e Initial load
duke
parents:
diff changeset
131 _area->_hwm = _hwm;
a61af66fc99e Initial load
duke
parents:
diff changeset
132 _area->_max = _max;
a61af66fc99e Initial load
duke
parents:
diff changeset
133
a61af66fc99e Initial load
duke
parents:
diff changeset
134 // clear out this chunk (to detect allocation bugs)
a61af66fc99e Initial load
duke
parents:
diff changeset
135 if (ZapResourceArea) memset(_hwm, badResourceValue, _max - _hwm);
a61af66fc99e Initial load
duke
parents:
diff changeset
136 _area->set_size_in_bytes(size_in_bytes());
a61af66fc99e Initial load
duke
parents:
diff changeset
137 }
a61af66fc99e Initial load
duke
parents:
diff changeset
138
a61af66fc99e Initial load
duke
parents:
diff changeset
139 ~ResourceMark() {
a61af66fc99e Initial load
duke
parents:
diff changeset
140 assert( _area->_nesting > 0, "must stack allocate RMs" );
a61af66fc99e Initial load
duke
parents:
diff changeset
141 debug_only(_area->_nesting--;)
a61af66fc99e Initial load
duke
parents:
diff changeset
142 reset_to_mark();
a61af66fc99e Initial load
duke
parents:
diff changeset
143 }
a61af66fc99e Initial load
duke
parents:
diff changeset
144
a61af66fc99e Initial load
duke
parents:
diff changeset
145
a61af66fc99e Initial load
duke
parents:
diff changeset
146 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
147 void free_malloced_objects() PRODUCT_RETURN;
a61af66fc99e Initial load
duke
parents:
diff changeset
148 size_t size_in_bytes() NOT_PRODUCT({ return _size_in_bytes; }) PRODUCT_RETURN0;
a61af66fc99e Initial load
duke
parents:
diff changeset
149 };
a61af66fc99e Initial load
duke
parents:
diff changeset
150
a61af66fc99e Initial load
duke
parents:
diff changeset
151 //------------------------------DeoptResourceMark-----------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
152 // A deopt resource mark releases all resources allocated after it was constructed
a61af66fc99e Initial load
duke
parents:
diff changeset
153 // when the destructor is called. Typically used as a local variable. It differs
a61af66fc99e Initial load
duke
parents:
diff changeset
154 // from a typical resource more in that it is C-Heap allocated so that deoptimization
a61af66fc99e Initial load
duke
parents:
diff changeset
155 // can use data structures that are arena based but are not amenable to vanilla
a61af66fc99e Initial load
duke
parents:
diff changeset
156 // ResourceMarks because deoptimization can not use a stack allocated mark. During
a61af66fc99e Initial load
duke
parents:
diff changeset
157 // deoptimization we go thru the following steps:
a61af66fc99e Initial load
duke
parents:
diff changeset
158 //
a61af66fc99e Initial load
duke
parents:
diff changeset
159 // 0: start in assembly stub and call either uncommon_trap/fetch_unroll_info
a61af66fc99e Initial load
duke
parents:
diff changeset
160 // 1: create the vframeArray (contains pointers to Resource allocated structures)
a61af66fc99e Initial load
duke
parents:
diff changeset
161 // This allocates the DeoptResourceMark.
a61af66fc99e Initial load
duke
parents:
diff changeset
162 // 2: return to assembly stub and remove stub frame and deoptee frame and create
a61af66fc99e Initial load
duke
parents:
diff changeset
163 // the new skeletal frames.
a61af66fc99e Initial load
duke
parents:
diff changeset
164 // 3: push new stub frame and call unpack_frames
a61af66fc99e Initial load
duke
parents:
diff changeset
165 // 4: retrieve information from the vframeArray to populate the skeletal frames
a61af66fc99e Initial load
duke
parents:
diff changeset
166 // 5: release the DeoptResourceMark
a61af66fc99e Initial load
duke
parents:
diff changeset
167 // 6: return to stub and eventually to interpreter
a61af66fc99e Initial load
duke
parents:
diff changeset
168 //
a61af66fc99e Initial load
duke
parents:
diff changeset
169 // With old style eager deoptimization the vframeArray was created by the vmThread there
a61af66fc99e Initial load
duke
parents:
diff changeset
170 // was no way for the vframeArray to contain resource allocated objects and so
a61af66fc99e Initial load
duke
parents:
diff changeset
171 // a complex set of data structures to simulate an array of vframes in CHeap memory
a61af66fc99e Initial load
duke
parents:
diff changeset
172 // was used. With new style lazy deoptimization the vframeArray is created in the
a61af66fc99e Initial load
duke
parents:
diff changeset
173 // the thread that will use it and we can use a much simpler scheme for the vframeArray
a61af66fc99e Initial load
duke
parents:
diff changeset
174 // leveraging existing data structures if we simply create a way to manage this one
a61af66fc99e Initial load
duke
parents:
diff changeset
175 // special need for a ResourceMark. If ResourceMark simply inherited from CHeapObj
a61af66fc99e Initial load
duke
parents:
diff changeset
176 // then existing ResourceMarks would work fine since no one use new to allocate them
a61af66fc99e Initial load
duke
parents:
diff changeset
177 // and they would be stack allocated. This leaves open the possibilty of accidental
a61af66fc99e Initial load
duke
parents:
diff changeset
178 // misuse so we simple duplicate the ResourceMark functionality here.
a61af66fc99e Initial load
duke
parents:
diff changeset
179
a61af66fc99e Initial load
duke
parents:
diff changeset
180 class DeoptResourceMark: public CHeapObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
181 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
182 ResourceArea *_area; // Resource area to stack allocate
a61af66fc99e Initial load
duke
parents:
diff changeset
183 Chunk *_chunk; // saved arena chunk
a61af66fc99e Initial load
duke
parents:
diff changeset
184 char *_hwm, *_max;
a61af66fc99e Initial load
duke
parents:
diff changeset
185 NOT_PRODUCT(size_t _size_in_bytes;)
a61af66fc99e Initial load
duke
parents:
diff changeset
186
a61af66fc99e Initial load
duke
parents:
diff changeset
187 void initialize(Thread *thread) {
a61af66fc99e Initial load
duke
parents:
diff changeset
188 _area = thread->resource_area();
a61af66fc99e Initial load
duke
parents:
diff changeset
189 _chunk = _area->_chunk;
a61af66fc99e Initial load
duke
parents:
diff changeset
190 _hwm = _area->_hwm;
a61af66fc99e Initial load
duke
parents:
diff changeset
191 _max= _area->_max;
a61af66fc99e Initial load
duke
parents:
diff changeset
192 NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();)
a61af66fc99e Initial load
duke
parents:
diff changeset
193 debug_only(_area->_nesting++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
194 assert( _area->_nesting > 0, "must stack allocate RMs" );
a61af66fc99e Initial load
duke
parents:
diff changeset
195 }
a61af66fc99e Initial load
duke
parents:
diff changeset
196
a61af66fc99e Initial load
duke
parents:
diff changeset
197 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
198
a61af66fc99e Initial load
duke
parents:
diff changeset
199 #ifndef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
200 DeoptResourceMark(Thread *thread) {
a61af66fc99e Initial load
duke
parents:
diff changeset
201 assert(thread == Thread::current(), "not the current thread");
a61af66fc99e Initial load
duke
parents:
diff changeset
202 initialize(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
203 }
a61af66fc99e Initial load
duke
parents:
diff changeset
204 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
205 DeoptResourceMark(Thread *thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
206 #endif // ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
207
a61af66fc99e Initial load
duke
parents:
diff changeset
208 DeoptResourceMark() { initialize(Thread::current()); }
a61af66fc99e Initial load
duke
parents:
diff changeset
209
a61af66fc99e Initial load
duke
parents:
diff changeset
210 DeoptResourceMark( ResourceArea *r ) :
a61af66fc99e Initial load
duke
parents:
diff changeset
211 _area(r), _chunk(r->_chunk), _hwm(r->_hwm), _max(r->_max) {
a61af66fc99e Initial load
duke
parents:
diff changeset
212 NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();)
a61af66fc99e Initial load
duke
parents:
diff changeset
213 debug_only(_area->_nesting++;)
a61af66fc99e Initial load
duke
parents:
diff changeset
214 assert( _area->_nesting > 0, "must stack allocate RMs" );
a61af66fc99e Initial load
duke
parents:
diff changeset
215 }
a61af66fc99e Initial load
duke
parents:
diff changeset
216
a61af66fc99e Initial load
duke
parents:
diff changeset
217 void reset_to_mark() {
a61af66fc99e Initial load
duke
parents:
diff changeset
218 if (UseMallocOnly) free_malloced_objects();
a61af66fc99e Initial load
duke
parents:
diff changeset
219
a61af66fc99e Initial load
duke
parents:
diff changeset
220 if( _chunk->next() ) // Delete later chunks
a61af66fc99e Initial load
duke
parents:
diff changeset
221 _chunk->next_chop();
a61af66fc99e Initial load
duke
parents:
diff changeset
222 _area->_chunk = _chunk; // Roll back arena to saved chunk
a61af66fc99e Initial load
duke
parents:
diff changeset
223 _area->_hwm = _hwm;
a61af66fc99e Initial load
duke
parents:
diff changeset
224 _area->_max = _max;
a61af66fc99e Initial load
duke
parents:
diff changeset
225
a61af66fc99e Initial load
duke
parents:
diff changeset
226 // clear out this chunk (to detect allocation bugs)
a61af66fc99e Initial load
duke
parents:
diff changeset
227 if (ZapResourceArea) memset(_hwm, badResourceValue, _max - _hwm);
a61af66fc99e Initial load
duke
parents:
diff changeset
228 _area->set_size_in_bytes(size_in_bytes());
a61af66fc99e Initial load
duke
parents:
diff changeset
229 }
a61af66fc99e Initial load
duke
parents:
diff changeset
230
a61af66fc99e Initial load
duke
parents:
diff changeset
231 ~DeoptResourceMark() {
a61af66fc99e Initial load
duke
parents:
diff changeset
232 assert( _area->_nesting > 0, "must stack allocate RMs" );
a61af66fc99e Initial load
duke
parents:
diff changeset
233 debug_only(_area->_nesting--;)
a61af66fc99e Initial load
duke
parents:
diff changeset
234 reset_to_mark();
a61af66fc99e Initial load
duke
parents:
diff changeset
235 }
a61af66fc99e Initial load
duke
parents:
diff changeset
236
a61af66fc99e Initial load
duke
parents:
diff changeset
237
a61af66fc99e Initial load
duke
parents:
diff changeset
238 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
239 void free_malloced_objects() PRODUCT_RETURN;
a61af66fc99e Initial load
duke
parents:
diff changeset
240 size_t size_in_bytes() NOT_PRODUCT({ return _size_in_bytes; }) PRODUCT_RETURN0;
a61af66fc99e Initial load
duke
parents:
diff changeset
241 };
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
242
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
243 #endif // SHARE_VM_MEMORY_RESOURCEAREA_HPP