• file
• revisions
• annotate
• diff
• comparison
• raw

src/share/vm/runtime/vframeArray.hpp@2a241e764894 (annotated)

src/share/vm/runtime/vframeArray.hpp

Fri, 10 Jun 2011 15:08:36 -0700

author

minqi

date

Fri, 10 Jun 2011 15:08:36 -0700

changeset 2964

2a241e764894

parent 2901

3d2ab563047a

child 3138

f6f3bb0ee072

permissions

-rw-r--r--

6941923: RFE: Handling large log files produced by long running Java Applications
Summary: supply optinal flags to realize gc log rotation
Reviewed-by: ysr, jwilhelm

duke@435	1	/*
stefank@2314	2	* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
duke@435	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435	4	*
duke@435	5	* This code is free software; you can redistribute it and/or modify it
duke@435	6	* under the terms of the GNU General Public License version 2 only, as
duke@435	7	* published by the Free Software Foundation.
duke@435	8	*
duke@435	9	* This code is distributed in the hope that it will be useful, but WITHOUT
duke@435	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435	12	* version 2 for more details (a copy is included in the LICENSE file that
duke@435	13	* accompanied this code).
duke@435	14	*
duke@435	15	* You should have received a copy of the GNU General Public License version
duke@435	16	* 2 along with this work; if not, write to the Free Software Foundation,
duke@435	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435	18	*
trims@1907	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907	20	* or visit www.oracle.com if you need additional information or have any
trims@1907	21	* questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
stefank@2314	25	#ifndef SHARE_VM_RUNTIME_VFRAMEARRAY_HPP
stefank@2314	26	#define SHARE_VM_RUNTIME_VFRAMEARRAY_HPP
stefank@2314	27
stefank@2314	28	#include "oops/arrayOop.hpp"
stefank@2314	29	#include "runtime/deoptimization.hpp"
stefank@2314	30	#include "runtime/frame.inline.hpp"
stefank@2314	31	#include "runtime/monitorChunk.hpp"
stefank@2314	32	#include "utilities/growableArray.hpp"
stefank@2314	33
duke@435	34	// A vframeArray is an array used for momentarily storing off stack Java method activations
duke@435	35	// during deoptimization. Essentially it is an array of vframes where each vframe
duke@435	36	// data is stored off stack. This structure will never exist across a safepoint so
duke@435	37	// there is no need to gc any oops that are stored in the structure.
duke@435	38
duke@435	39
duke@435	40	class LocalsClosure;
duke@435	41	class ExpressionStackClosure;
duke@435	42	class MonitorStackClosure;
duke@435	43	class MonitorArrayElement;
duke@435	44	class StackValueCollection;
duke@435	45
duke@435	46	// A vframeArrayElement is an element of a vframeArray. Each element
duke@435	47	// represent an interpreter frame which will eventually be created.
duke@435	48
duke@435	49	class vframeArrayElement : public _ValueObj {
duke@435	50	private:
duke@435	51
duke@435	52	frame _frame; // the interpreter frame we will unpack into
cfang@1335	53	int _bci; // raw bci for this vframe
cfang@1335	54	bool _reexecute; // whether sould we reexecute this bytecode
duke@435	55	methodOop _method; // the method for this vframe
duke@435	56	MonitorChunk* _monitors; // active monitors for this vframe
duke@435	57	StackValueCollection* _locals;
duke@435	58	StackValueCollection* _expressions;
duke@435	59
duke@435	60	public:
duke@435	61
duke@435	62	frame* iframe(void) { return &_frame; }
duke@435	63
duke@435	64	int bci(void) const;
duke@435	65
duke@435	66	int raw_bci(void) const { return _bci; }
cfang@1335	67	bool should_reexecute(void) const { return _reexecute; }
duke@435	68
duke@435	69	methodOop method(void) const { return _method; }
duke@435	70
duke@435	71	MonitorChunk* monitors(void) const { return _monitors; }
duke@435	72
duke@435	73	void free_monitors(JavaThread* jt);
duke@435	74
duke@435	75	StackValueCollection* locals(void) const { return _locals; }
duke@435	76
duke@435	77	StackValueCollection* expressions(void) const { return _expressions; }
duke@435	78
duke@435	79	void fill_in(compiledVFrame* vf);
duke@435	80
duke@435	81	// Formerly part of deoptimizedVFrame
duke@435	82
duke@435	83
duke@435	84	// Returns the on stack word size for this frame
duke@435	85	// callee_parameters is the number of callee locals residing inside this frame
never@2901	86	int on_stack_size(int caller_actual_parameters,
never@2901	87	int callee_parameters,
duke@435	88	int callee_locals,
duke@435	89	bool is_top_frame,
duke@435	90	int popframe_extra_stack_expression_els) const;
duke@435	91
duke@435	92	// Unpacks the element to skeletal interpreter frame
never@2901	93	void unpack_on_stack(int caller_actual_parameters,
never@2901	94	int callee_parameters,
duke@435	95	int callee_locals,
duke@435	96	frame* caller,
duke@435	97	bool is_top_frame,
duke@435	98	int exec_mode);
duke@435	99
duke@435	100	#ifndef PRODUCT
duke@435	101	void print(outputStream* st);
duke@435	102	#endif /* PRODUCT */
duke@435	103	};
duke@435	104
duke@435	105	// this can be a ResourceObj if we don't save the last one...
duke@435	106	// but it does make debugging easier even if we can't look
duke@435	107	// at the data in each vframeElement
duke@435	108
duke@435	109	class vframeArray: public CHeapObj {
duke@435	110	private:
duke@435	111
duke@435	112
duke@435	113	// Here is what a vframeArray looks like in memory
duke@435	114
duke@435	115	/*
duke@435	116	fixed part
duke@435	117	description of the original frame
duke@435	118	_frames - number of vframes in this array
duke@435	119	adapter info
duke@435	120	callee register save area
duke@435	121	variable part
duke@435	122	vframeArrayElement [ 0 ]
duke@435	123	...
duke@435	124	vframeArrayElement [_frames - 1]
duke@435	125
duke@435	126	*/
duke@435	127
duke@435	128	JavaThread* _owner_thread;
duke@435	129	vframeArray* _next;
duke@435	130	frame _original; // the original frame of the deoptee
duke@435	131	frame _caller; // caller of root frame in vframeArray
duke@435	132	frame _sender;
duke@435	133
duke@435	134	Deoptimization::UnrollBlock* _unroll_block;
duke@435	135	int _frame_size;
duke@435	136
duke@435	137	int _frames; // number of javavframes in the array (does not count any adapter)
duke@435	138
duke@435	139	intptr_t _callee_registers[RegisterMap::reg_count];
duke@435	140	unsigned char _valid[RegisterMap::reg_count];
duke@435	141
duke@435	142	vframeArrayElement _elements[1]; // First variable section.
duke@435	143
duke@435	144	void fill_in_element(int index, compiledVFrame* vf);
duke@435	145
duke@435	146	bool is_location_valid(int i) const { return _valid[i] != 0; }
duke@435	147	void set_location_valid(int i, bool valid) { _valid[i] = valid; }
duke@435	148
duke@435	149	public:
duke@435	150
duke@435	151
duke@435	152	// Tells whether index is within bounds.
duke@435	153	bool is_within_bounds(int index) const { return 0 <= index && index < frames(); }
duke@435	154
duke@435	155	// Accessores for instance variable
duke@435	156	int frames() const { return _frames; }
duke@435	157
duke@435	158	static vframeArray* allocate(JavaThread* thread, int frame_size, GrowableArray<compiledVFrame*>* chunk,
duke@435	159	RegisterMap* reg_map, frame sender, frame caller, frame self);
duke@435	160
duke@435	161
duke@435	162	vframeArrayElement* element(int index) { assert(is_within_bounds(index), "Bad index"); return &_elements[index]; }
duke@435	163
duke@435	164	// Allocates a new vframe in the array and fills the array with vframe information in chunk
duke@435	165	void fill_in(JavaThread* thread, int frame_size, GrowableArray<compiledVFrame*>* chunk, const RegisterMap *reg_map);
duke@435	166
duke@435	167	// Returns the owner of this vframeArray
duke@435	168	JavaThread* owner_thread() const { return _owner_thread; }
duke@435	169
duke@435	170	// Accessors for next
duke@435	171	vframeArray* next() const { return _next; }
duke@435	172	void set_next(vframeArray* value) { _next = value; }
duke@435	173
duke@435	174	// Accessors for sp
duke@435	175	intptr_t* sp() const { return _original.sp(); }
duke@435	176
duke@435	177	intptr_t* unextended_sp() const { return _original.unextended_sp(); }
duke@435	178
duke@435	179	address original_pc() const { return _original.pc(); }
duke@435	180
duke@435	181	frame original() const { return _original; }
duke@435	182
duke@435	183	frame caller() const { return _caller; }
duke@435	184
duke@435	185	frame sender() const { return _sender; }
duke@435	186
duke@435	187	// Accessors for unroll block
duke@435	188	Deoptimization::UnrollBlock* unroll_block() const { return _unroll_block; }
duke@435	189	void set_unroll_block(Deoptimization::UnrollBlock* block) { _unroll_block = block; }
duke@435	190
duke@435	191	// Returns the size of the frame that got deoptimized
duke@435	192	int frame_size() const { return _frame_size; }
duke@435	193
duke@435	194	// Unpack the array on the stack passed in stack interval
never@2901	195	void unpack_to_stack(frame &unpack_frame, int exec_mode, int caller_actual_parameters);
duke@435	196
duke@435	197	// Deallocates monitor chunks allocated during deoptimization.
duke@435	198	// This should be called when the array is not used anymore.
duke@435	199	void deallocate_monitor_chunks();
duke@435	200
duke@435	201
duke@435	202
duke@435	203	// Accessor for register map
duke@435	204	address register_location(int i) const;
duke@435	205
duke@435	206	void print_on_2(outputStream* st) PRODUCT_RETURN;
duke@435	207	void print_value_on(outputStream* st) const PRODUCT_RETURN;
duke@435	208
duke@435	209	#ifndef PRODUCT
duke@435	210	// Comparing
duke@435	211	bool structural_compare(JavaThread* thread, GrowableArray<compiledVFrame*>* chunk);
duke@435	212	#endif
duke@435	213
duke@435	214	};
stefank@2314	215
stefank@2314	216	#endif // SHARE_VM_RUNTIME_VFRAMEARRAY_HPP