Mercurial > hg > graal-compiler
view src/share/vm/interpreter/templateTable.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 | b92c45f2bc75 |
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_INTERPRETER_TEMPLATETABLE_HPP #define SHARE_VM_INTERPRETER_TEMPLATETABLE_HPP #include "interpreter/bytecodes.hpp" #include "memory/allocation.hpp" #include "runtime/frame.hpp" #ifdef TARGET_ARCH_MODEL_x86_32 # include "interp_masm_x86_32.hpp" #endif #ifdef TARGET_ARCH_MODEL_x86_64 # include "interp_masm_x86_64.hpp" #endif #ifdef TARGET_ARCH_MODEL_sparc # include "interp_masm_sparc.hpp" #endif #ifdef TARGET_ARCH_MODEL_zero # include "interp_masm_zero.hpp" #endif #ifndef CC_INTERP // All the necessary definitions used for (bytecode) template generation. Instead of // spreading the implementation functionality for each bytecode in the interpreter // and the snippet generator, a template is assigned to each bytecode which can be // used to generate the bytecode's implementation if needed. // A Template describes the properties of a code template for a given bytecode // and provides a generator to generate the code template. class Template VALUE_OBJ_CLASS_SPEC { private: enum Flags { uses_bcp_bit, // set if template needs the bcp pointing to bytecode does_dispatch_bit, // set if template dispatches on its own calls_vm_bit, // set if template calls the vm wide_bit // set if template belongs to a wide instruction }; typedef void (*generator)(int arg); int _flags; // describes interpreter template properties (bcp unknown) TosState _tos_in; // tos cache state before template execution TosState _tos_out; // tos cache state after template execution generator _gen; // template code generator int _arg; // argument for template code generator void initialize(int flags, TosState tos_in, TosState tos_out, generator gen, int arg); friend class TemplateTable; public: Bytecodes::Code bytecode() const; bool is_valid() const { return _gen != NULL; } bool uses_bcp() const { return (_flags & (1 << uses_bcp_bit )) != 0; } bool does_dispatch() const { return (_flags & (1 << does_dispatch_bit)) != 0; } bool calls_vm() const { return (_flags & (1 << calls_vm_bit )) != 0; } bool is_wide() const { return (_flags & (1 << wide_bit )) != 0; } TosState tos_in() const { return _tos_in; } TosState tos_out() const { return _tos_out; } void generate(InterpreterMacroAssembler* masm); }; // The TemplateTable defines all Templates and provides accessor functions // to get the template for a given bytecode. class TemplateTable: AllStatic { public: enum Operation { add, sub, mul, div, rem, _and, _or, _xor, shl, shr, ushr }; enum Condition { equal, not_equal, less, less_equal, greater, greater_equal }; enum CacheByte { f1_byte = 1, f2_byte = 2, f1_oop = 0x11 }; // byte_no codes private: static bool _is_initialized; // true if TemplateTable has been initialized static Template _template_table [Bytecodes::number_of_codes]; static Template _template_table_wide[Bytecodes::number_of_codes]; static Template* _desc; // the current template to be generated static Bytecodes::Code bytecode() { return _desc->bytecode(); } static BarrierSet* _bs; // Cache the barrier set. public: //%note templates_1 static InterpreterMacroAssembler* _masm; // the assembler used when generating templates private: // special registers static inline Address at_bcp(int offset); // helpers static void unimplemented_bc(); static void patch_bytecode(Bytecodes::Code bc, Register scratch1, Register scratch2, bool load_bc_in_scratch = true); // C calls static void call_VM(Register oop_result, address entry_point); static void call_VM(Register oop_result, address entry_point, Register arg_1); static void call_VM(Register oop_result, address entry_point, Register arg_1, Register arg_2); static void call_VM(Register oop_result, address entry_point, Register arg_1, Register arg_2, Register arg_3); // these overloadings are not presently used on SPARC: static void call_VM(Register oop_result, Register last_java_sp, address entry_point); static void call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1); static void call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, Register arg_2); static void call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, Register arg_2, Register arg_3); // bytecodes static void nop(); static void aconst_null(); static void iconst(int value); static void lconst(int value); static void fconst(int value); static void dconst(int value); static void bipush(); static void sipush(); static void ldc(bool wide); static void ldc2_w(); static void fast_aldc(bool wide); static void locals_index(Register reg, int offset = 1); static void iload(); static void fast_iload(); static void fast_iload2(); static void fast_icaload(); static void lload(); static void fload(); static void dload(); static void aload(); static void locals_index_wide(Register reg); static void wide_iload(); static void wide_lload(); static void wide_fload(); static void wide_dload(); static void wide_aload(); static void iaload(); static void laload(); static void faload(); static void daload(); static void aaload(); static void baload(); static void caload(); static void saload(); static void iload(int n); static void lload(int n); static void fload(int n); static void dload(int n); static void aload(int n); static void aload_0(); static void istore(); static void lstore(); static void fstore(); static void dstore(); static void astore(); static void wide_istore(); static void wide_lstore(); static void wide_fstore(); static void wide_dstore(); static void wide_astore(); static void iastore(); static void lastore(); static void fastore(); static void dastore(); static void aastore(); static void bastore(); static void castore(); static void sastore(); static void istore(int n); static void lstore(int n); static void fstore(int n); static void dstore(int n); static void astore(int n); static void pop(); static void pop2(); static void dup(); static void dup_x1(); static void dup_x2(); static void dup2(); static void dup2_x1(); static void dup2_x2(); static void swap(); static void iop2(Operation op); static void lop2(Operation op); static void fop2(Operation op); static void dop2(Operation op); static void idiv(); static void irem(); static void lmul(); static void ldiv(); static void lrem(); static void lshl(); static void lshr(); static void lushr(); static void ineg(); static void lneg(); static void fneg(); static void dneg(); static void iinc(); static void wide_iinc(); static void convert(); static void lcmp(); static void float_cmp (bool is_float, int unordered_result); static void float_cmp (int unordered_result); static void double_cmp(int unordered_result); static void count_calls(Register method, Register temp); static void branch(bool is_jsr, bool is_wide); static void if_0cmp (Condition cc); static void if_icmp (Condition cc); static void if_nullcmp(Condition cc); static void if_acmp (Condition cc); static void _goto(); static void jsr(); static void ret(); static void wide_ret(); static void goto_w(); static void jsr_w(); static void tableswitch(); static void lookupswitch(); static void fast_linearswitch(); static void fast_binaryswitch(); static void _return(TosState state); static void resolve_cache_and_index(int byte_no, // one of 1,2,11 Register result , // either noreg or output for f1/f2 Register cache, // output for CP cache Register index, // output for CP index size_t index_size); // one of 1,2,4 static void load_invoke_cp_cache_entry(int byte_no, Register method, Register itable_index, Register flags, bool is_invokevirtual, bool is_virtual_final, bool is_invokedynamic); static void load_field_cp_cache_entry(Register obj, Register cache, Register index, Register offset, Register flags, bool is_static); static void invokevirtual(int byte_no); static void invokespecial(int byte_no); static void invokestatic(int byte_no); static void invokeinterface(int byte_no); static void invokedynamic(int byte_no); static void fast_invokevfinal(int byte_no); static void getfield_or_static(int byte_no, bool is_static); static void putfield_or_static(int byte_no, bool is_static); static void getfield(int byte_no); static void putfield(int byte_no); static void getstatic(int byte_no); static void putstatic(int byte_no); static void pop_and_check_object(Register obj); static void _new(); static void newarray(); static void anewarray(); static void arraylength(); static void checkcast(); static void instanceof(); static void athrow(); static void monitorenter(); static void monitorexit(); static void wide(); static void multianewarray(); static void fast_xaccess(TosState state); static void fast_accessfield(TosState state); static void fast_storefield(TosState state); static void _breakpoint(); static void shouldnotreachhere(); // jvmti support static void jvmti_post_field_access(Register cache, Register index, bool is_static, bool has_tos); static void jvmti_post_field_mod(Register cache, Register index, bool is_static); static void jvmti_post_fast_field_mod(); // debugging of TemplateGenerator static void transition(TosState tos_in, TosState tos_out);// checks if in/out states expected by template generator correspond to table entries // initialization helpers static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)( ), char filler ); static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)(int arg ), int arg ); static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)(bool arg ), bool arg ); static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)(TosState tos), TosState tos); static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)(Operation op), Operation op); static void def(Bytecodes::Code code, int flags, TosState in, TosState out, void (*gen)(Condition cc), Condition cc); friend class Template; // InterpreterMacroAssembler::is_a(), etc., need TemplateTable::call_VM(). friend class InterpreterMacroAssembler; public: // Initialization static void initialize(); static void pd_initialize(); // Templates static Template* template_for (Bytecodes::Code code) { Bytecodes::check (code); return &_template_table [code]; } static Template* template_for_wide(Bytecodes::Code code) { Bytecodes::wide_check(code); return &_template_table_wide[code]; } // Platform specifics #ifdef TARGET_ARCH_MODEL_x86_32 # include "templateTable_x86_32.hpp" #endif #ifdef TARGET_ARCH_MODEL_x86_64 # include "templateTable_x86_64.hpp" #endif #ifdef TARGET_ARCH_MODEL_sparc # include "templateTable_sparc.hpp" #endif #ifdef TARGET_ARCH_MODEL_zero # include "templateTable_zero.hpp" #endif }; #endif /* !CC_INTERP */ #endif // SHARE_VM_INTERPRETER_TEMPLATETABLE_HPP