Mercurial > hg > graal-compiler
view src/share/vm/runtime/rframe.hpp @ 2149:7e37af9d69ef
7011379: G1: overly long concurrent marking cycles
Summary: This changeset introduces filtering of SATB buffers at the point when they are about to be enqueued. If this filtering clears enough entries on each buffer, the buffer can then be re-used and not enqueued. This cuts down the number of SATB buffers that need to be processed by the concurrent marking threads.
Reviewed-by: johnc, ysr
author | tonyp |
---|---|
date | Wed, 19 Jan 2011 09:35:17 -0500 |
parents | f95d63e2154a |
children | da91efe96a93 |
line wrap: on
line source
/* * Copyright (c) 1997, 2010, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #ifndef SHARE_VM_RUNTIME_RFRAME_HPP #define SHARE_VM_RUNTIME_RFRAME_HPP #include "memory/allocation.hpp" #include "runtime/frame.inline.hpp" // rframes ("recompiler frames") decorate stack frames with some extra information // needed by the recompiler. The recompiler views the stack (at the time of recompilation) // as a list of rframes. class RFrame : public ResourceObj { protected: const frame _fr; // my frame JavaThread* const _thread; // thread where frame resides. RFrame* _caller; // caller / callee rframes (or NULL) RFrame*const _callee; const int _num; // stack frame number (0 = most recent) int _invocations; // current invocation estimate (for this frame) // (i.e., how often was this frame called) int _distance; // recompilation search "distance" (measured in # of interpreted frames) RFrame(frame fr, JavaThread* thread, RFrame*const callee); virtual void init() = 0; // compute invocations, loopDepth, etc. void print(const char* name); public: static RFrame* new_RFrame(frame fr, JavaThread* thread, RFrame*const callee); virtual bool is_interpreted() const { return false; } virtual bool is_compiled() const { return false; } int distance() const { return _distance; } void set_distance(int d); int invocations() const { return _invocations; } int num() const { return _num; } frame fr() const { return _fr; } JavaThread* thread() const { return _thread; } virtual int cost() const = 0; // estimated inlining cost (size) virtual methodHandle top_method() const = 0; virtual javaVFrame* top_vframe() const = 0; virtual nmethod* nm() const { ShouldNotCallThis(); return NULL; } RFrame* caller(); RFrame* callee() const { return _callee; } RFrame* parent() const; // rframe containing lexical scope (if any) virtual void print() = 0; static int computeSends(methodOop m); static int computeSends(nmethod* nm); static int computeCumulSends(methodOop m); static int computeCumulSends(nmethod* nm); }; class CompiledRFrame : public RFrame { // frame containing a compiled method protected: nmethod* _nm; javaVFrame* _vf; // top vframe; may be NULL (for most recent frame) methodHandle _method; // top method CompiledRFrame(frame fr, JavaThread* thread, RFrame*const callee); void init(); friend class RFrame; public: CompiledRFrame(frame fr, JavaThread* thread); // for nmethod triggering its counter (callee == NULL) bool is_compiled() const { return true; } methodHandle top_method() const { return _method; } javaVFrame* top_vframe() const { return _vf; } nmethod* nm() const { return _nm; } int cost() const; void print(); }; class InterpretedRFrame : public RFrame { // interpreter frame protected: javaVFrame* _vf; // may be NULL (for most recent frame) methodHandle _method; InterpretedRFrame(frame fr, JavaThread* thread, RFrame*const callee); void init(); friend class RFrame; public: InterpretedRFrame(frame fr, JavaThread* thread, methodHandle m); // constructor for method triggering its invocation counter bool is_interpreted() const { return true; } methodHandle top_method() const { return _method; } javaVFrame* top_vframe() const { return _vf; } int cost() const; void print(); }; // treat deoptimized frames as interpreted class DeoptimizedRFrame : public InterpretedRFrame { protected: DeoptimizedRFrame(frame fr, JavaThread* thread, RFrame*const callee); friend class RFrame; public: void print(); }; #endif // SHARE_VM_RUNTIME_RFRAME_HPP