Mon, 12 Aug 2019 18:30:40 +0300
8223147: JFR Backport
8199712: Flight Recorder
8203346: JFR: Inconsistent signature of jfr_add_string_constant
8195817: JFR.stop should require name of recording
8195818: JFR.start should increase autogenerated name by one
8195819: Remove recording=x from jcmd JFR.check output
8203921: JFR thread sampling is missing fixes from JDK-8194552
8203929: Limit amount of data for JFR.dump
8203664: JFR start failure after AppCDS archive created with JFR StartFlightRecording
8003209: JFR events for network utilization
8207392: [PPC64] Implement JFR profiling
8202835: jfr/event/os/TestSystemProcess.java fails on missing events
Summary: Backport JFR from JDK11. Initial integration
Reviewed-by: neugens
1 /*
2 * Copyright (c) 1997, 2017, 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 */
25 #ifndef SHARE_VM_MEMORY_RESOURCEAREA_HPP
26 #define SHARE_VM_MEMORY_RESOURCEAREA_HPP
28 #include "memory/allocation.hpp"
29 #include "runtime/thread.inline.hpp"
31 // The resource area holds temporary data structures in the VM.
32 // The actual allocation areas are thread local. Typical usage:
33 //
34 // ...
35 // {
36 // ResourceMark rm;
37 // int foo[] = NEW_RESOURCE_ARRAY(int, 64);
38 // ...
39 // }
40 // ...
42 //------------------------------ResourceArea-----------------------------------
43 // A ResourceArea is an Arena that supports safe usage of ResourceMark.
44 class ResourceArea: public Arena {
45 friend class ResourceMark;
46 friend class DeoptResourceMark;
47 friend class VMStructs;
48 debug_only(int _nesting;) // current # of nested ResourceMarks
49 debug_only(static int _warned;) // to suppress multiple warnings
51 public:
52 ResourceArea(MEMFLAGS flags = mtThread) : Arena(flags) {
53 debug_only(_nesting = 0;)
54 }
56 ResourceArea(size_t init_size, MEMFLAGS flags = mtThread) : Arena(flags, init_size) {
57 debug_only(_nesting = 0;);
58 }
60 char* allocate_bytes(size_t size, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) {
61 #ifdef ASSERT
62 if (_nesting < 1 && !_warned++)
63 fatal("memory leak: allocating without ResourceMark");
64 if (UseMallocOnly) {
65 // use malloc, but save pointer in res. area for later freeing
66 char** save = (char**)internal_malloc_4(sizeof(char*));
67 return (*save = (char*)os::malloc(size, mtThread, CURRENT_PC));
68 }
69 #endif
70 return (char*)Amalloc(size, alloc_failmode);
71 }
73 // Bias this resource area to specific memory type
74 // (by default, ResourceArea is tagged as mtThread, per-thread general purpose storage)
75 void bias_to(MEMFLAGS flags);
77 debug_only(int nesting() const { return _nesting; })
78 };
81 //------------------------------ResourceMark-----------------------------------
82 // A resource mark releases all resources allocated after it was constructed
83 // when the destructor is called. Typically used as a local variable.
84 class ResourceMark: public StackObj {
85 protected:
86 ResourceArea *_area; // Resource area to stack allocate
87 Chunk *_chunk; // saved arena chunk
88 char *_hwm, *_max;
89 size_t _size_in_bytes;
90 #ifdef ASSERT
91 Thread* _thread;
92 ResourceMark* _previous_resource_mark;
93 #endif //ASSERT
95 void initialize(Thread *thread) {
96 _area = thread->resource_area();
97 _chunk = _area->_chunk;
98 _hwm = _area->_hwm;
99 _max= _area->_max;
100 _size_in_bytes = _area->size_in_bytes();
101 debug_only(_area->_nesting++;)
102 assert( _area->_nesting > 0, "must stack allocate RMs" );
103 #ifdef ASSERT
104 _thread = thread;
105 _previous_resource_mark = thread->current_resource_mark();
106 thread->set_current_resource_mark(this);
107 #endif // ASSERT
108 }
109 public:
111 #ifndef ASSERT
112 ResourceMark(Thread *thread) {
113 assert(thread == Thread::current(), "not the current thread");
114 initialize(thread);
115 }
116 #else
117 ResourceMark(Thread *thread);
118 #endif // ASSERT
120 ResourceMark() { initialize(Thread::current()); }
122 ResourceMark( ResourceArea *r ) :
123 _area(r), _chunk(r->_chunk), _hwm(r->_hwm), _max(r->_max) {
124 _size_in_bytes = r->_size_in_bytes;
125 debug_only(_area->_nesting++;)
126 assert( _area->_nesting > 0, "must stack allocate RMs" );
127 #ifdef ASSERT
128 Thread* thread = ThreadLocalStorage::thread();
129 if (thread != NULL) {
130 _thread = thread;
131 _previous_resource_mark = thread->current_resource_mark();
132 thread->set_current_resource_mark(this);
133 } else {
134 _thread = NULL;
135 _previous_resource_mark = NULL;
136 }
137 #endif // ASSERT
138 }
140 void reset_to_mark() {
141 if (UseMallocOnly) free_malloced_objects();
143 if( _chunk->next() ) { // Delete later chunks
144 // reset arena size before delete chunks. Otherwise, the total
145 // arena size could exceed total chunk size
146 assert(_area->size_in_bytes() > size_in_bytes(), "Sanity check");
147 _area->set_size_in_bytes(size_in_bytes());
148 _chunk->next_chop();
149 } else {
150 assert(_area->size_in_bytes() == size_in_bytes(), "Sanity check");
151 }
152 _area->_chunk = _chunk; // Roll back arena to saved chunk
153 _area->_hwm = _hwm;
154 _area->_max = _max;
156 // clear out this chunk (to detect allocation bugs)
157 if (ZapResourceArea) memset(_hwm, badResourceValue, _max - _hwm);
158 }
160 ~ResourceMark() {
161 assert( _area->_nesting > 0, "must stack allocate RMs" );
162 debug_only(_area->_nesting--;)
163 reset_to_mark();
164 #ifdef ASSERT
165 if (_thread != NULL) {
166 _thread->set_current_resource_mark(_previous_resource_mark);
167 }
168 #endif // ASSERT
169 }
172 private:
173 void free_malloced_objects() PRODUCT_RETURN;
174 size_t size_in_bytes() { return _size_in_bytes; }
175 };
177 //------------------------------DeoptResourceMark-----------------------------------
178 // A deopt resource mark releases all resources allocated after it was constructed
179 // when the destructor is called. Typically used as a local variable. It differs
180 // from a typical resource more in that it is C-Heap allocated so that deoptimization
181 // can use data structures that are arena based but are not amenable to vanilla
182 // ResourceMarks because deoptimization can not use a stack allocated mark. During
183 // deoptimization we go thru the following steps:
184 //
185 // 0: start in assembly stub and call either uncommon_trap/fetch_unroll_info
186 // 1: create the vframeArray (contains pointers to Resource allocated structures)
187 // This allocates the DeoptResourceMark.
188 // 2: return to assembly stub and remove stub frame and deoptee frame and create
189 // the new skeletal frames.
190 // 3: push new stub frame and call unpack_frames
191 // 4: retrieve information from the vframeArray to populate the skeletal frames
192 // 5: release the DeoptResourceMark
193 // 6: return to stub and eventually to interpreter
194 //
195 // With old style eager deoptimization the vframeArray was created by the vmThread there
196 // was no way for the vframeArray to contain resource allocated objects and so
197 // a complex set of data structures to simulate an array of vframes in CHeap memory
198 // was used. With new style lazy deoptimization the vframeArray is created in the
199 // the thread that will use it and we can use a much simpler scheme for the vframeArray
200 // leveraging existing data structures if we simply create a way to manage this one
201 // special need for a ResourceMark. If ResourceMark simply inherited from CHeapObj
202 // then existing ResourceMarks would work fine since no one use new to allocate them
203 // and they would be stack allocated. This leaves open the possibilty of accidental
204 // misuse so we simple duplicate the ResourceMark functionality here.
206 class DeoptResourceMark: public CHeapObj<mtInternal> {
207 protected:
208 ResourceArea *_area; // Resource area to stack allocate
209 Chunk *_chunk; // saved arena chunk
210 char *_hwm, *_max;
211 size_t _size_in_bytes;
213 void initialize(Thread *thread) {
214 _area = thread->resource_area();
215 _chunk = _area->_chunk;
216 _hwm = _area->_hwm;
217 _max= _area->_max;
218 _size_in_bytes = _area->size_in_bytes();
219 debug_only(_area->_nesting++;)
220 assert( _area->_nesting > 0, "must stack allocate RMs" );
221 }
223 public:
225 #ifndef ASSERT
226 DeoptResourceMark(Thread *thread) {
227 assert(thread == Thread::current(), "not the current thread");
228 initialize(thread);
229 }
230 #else
231 DeoptResourceMark(Thread *thread);
232 #endif // ASSERT
234 DeoptResourceMark() { initialize(Thread::current()); }
236 DeoptResourceMark( ResourceArea *r ) :
237 _area(r), _chunk(r->_chunk), _hwm(r->_hwm), _max(r->_max) {
238 _size_in_bytes = _area->size_in_bytes();
239 debug_only(_area->_nesting++;)
240 assert( _area->_nesting > 0, "must stack allocate RMs" );
241 }
243 void reset_to_mark() {
244 if (UseMallocOnly) free_malloced_objects();
246 if( _chunk->next() ) { // Delete later chunks
247 // reset arena size before delete chunks. Otherwise, the total
248 // arena size could exceed total chunk size
249 assert(_area->size_in_bytes() > size_in_bytes(), "Sanity check");
250 _area->set_size_in_bytes(size_in_bytes());
251 _chunk->next_chop();
252 } else {
253 assert(_area->size_in_bytes() == size_in_bytes(), "Sanity check");
254 }
255 _area->_chunk = _chunk; // Roll back arena to saved chunk
256 _area->_hwm = _hwm;
257 _area->_max = _max;
259 // clear out this chunk (to detect allocation bugs)
260 if (ZapResourceArea) memset(_hwm, badResourceValue, _max - _hwm);
261 }
263 ~DeoptResourceMark() {
264 assert( _area->_nesting > 0, "must stack allocate RMs" );
265 debug_only(_area->_nesting--;)
266 reset_to_mark();
267 }
270 private:
271 void free_malloced_objects() PRODUCT_RETURN;
272 size_t size_in_bytes() { return _size_in_bytes; };
273 };
275 #endif // SHARE_VM_MEMORY_RESOURCEAREA_HPP