概述

在前面的文章中介绍了编译执行时，安全点的触发机制，本文将继续了解解释执行时，安全点是如何生效的；

字节码

void TemplateTable::ret() {
  transition(vtos, vtos);
  locals_index(rbx);
  LP64_ONLY(__ movslq(rbx, iaddress(rbx))); // get return bci, compute return bcp
  NOT_LP64(__ movptr(rbx, iaddress(rbx)));
  __ profile_ret(rbx, rcx);
  __ get_method(rax);
  __ movptr(rbcp, Address(rax, Method::const_offset()));
  __ lea(rbcp, Address(rbcp, rbx, Address::times_1,
                      ConstMethod::codes_offset()));
  __ dispatch_next(vtos, 0, true);
}

TemplateTable中定义了ret字节码指令的执行入口函数，里面调用了__ dispatch_next方法

InterpreterMacroAssembler::dispatch_next方法

void InterpreterMacroAssembler::dispatch_next(TosState state, int step, bool generate_poll) {
  // load next bytecode (load before advancing _bcp_register to prevent AGI)
  load_unsigned_byte(rbx, Address(_bcp_register, step));
  // advance _bcp_register
  increment(_bcp_register, step);
  dispatch_base(state, Interpreter::dispatch_table(state), true, generate_poll);
}

主要看InterpreterMacroAssembler::dispatch_next方法的第三个参数generate_poll传入的值为true;

void InterpreterMacroAssembler::dispatch_base(TosState state,
                                              address* table,
                                              bool verifyoop,
                                              bool generate_poll) {
 ......
  address* const safepoint_table = Interpreter::safept_table(state);
#ifdef _LP64
  Label no_safepoint, dispatch;
  if (table != safepoint_table && generate_poll) {
    NOT_PRODUCT(block_comment("Thread-local Safepoint poll"));
    testb(Address(r15_thread, JavaThread::polling_word_offset()), SafepointMechanism::poll_bit());

    jccb(Assembler::zero, no_safepoint);
    lea(rscratch1, ExternalAddress((address)safepoint_table));
    jmpb(dispatch);
  }

  bind(no_safepoint);
  lea(rscratch1, ExternalAddress((address)table));
  bind(dispatch);
  jmp(Address(rscratch1, rbx, Address::times_8));

#else
  Address index(noreg, rbx, Address::times_ptr);
  if (table != safepoint_table && generate_poll) {
    Label no_safepoint;
    const Register thread = rcx;
    get_thread(thread);
    testb(Address(thread, JavaThread::polling_word_offset()), SafepointMechanism::poll_bit());

    jccb(Assembler::zero, no_safepoint);
    ArrayAddress dispatch_addr(ExternalAddress((address)safepoint_table), index);
    jump(dispatch_addr);
    bind(no_safepoint);
  }

  {
    ArrayAddress dispatch_addr(ExternalAddress((address)table), index);
    jump(dispatch_addr);
  }
#endif // _LP64
}

从这里看到当generate_poll为true时，ret指令执行的时候会判断当前线程的_polling_word值，如果发现需要进入安全点，则执行safepoint_table里面的函数，那么safepoint_table是什么呢？

safepoint_table

TemplateInterpreter中定义了DispatchTable类型的变量：

///templateInterpreter.hpp
 static DispatchTable _active_table;                           // the active    dispatch table (used by the interpreter for dispatch)
  static DispatchTable _normal_table;                           // the normal    dispatch table (used to set the active table in normal mode)
  static DispatchTable _safept_table;                           // the safepoint dispatch table (used to set the active table for safepoints)

其中_safept_table的初始化逻辑是在函数generate_all中：

//templateInterpreterGenerator.cpp
TemplateInterpreterGenerator::generate_all(){
......
   // Bytecodes
   set_entry_points_for_all_bytes();
  // installation of code in other places in the runtime
  // (ExcutableCodeManager calls not needed to copy the entries)
  set_safepoints_for_all_bytes();
......
}

//templateInterpreterGenerator.cpp
void TemplateInterpreterGenerator::set_safepoints_for_all_bytes() {
  for (int i = 0; i < DispatchTable::length; i++) {
    Bytecodes::Code code = (Bytecodes::Code)i;
    if (Bytecodes::is_defined(code)) Interpreter::_safept_table.set_entry(code, Interpreter::_safept_entry);
  }
}

可以看到这里会把所有字节码的指令都关联到Interpreter::_safept_entry

Interpreter::_safept_entry

Interpreter::_safept_entry的初始化代码也在TemplateInterpreterGenerator::generate_all()方法

 { CodeletMark cm(_masm, "safepoint entry points");
    Interpreter::_safept_entry =
      EntryPoint(
                 generate_safept_entry_for(atos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
                 generate_safept_entry_for(itos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
                 generate_safept_entry_for(ltos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
                 generate_safept_entry_for(ftos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
                 generate_safept_entry_for(dtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
                 generate_safept_entry_for(vtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint))
                 );
  }

JRT_ENTRY(void, InterpreterRuntime::at_safepoint(JavaThread* current))
  // We used to need an explict preserve_arguments here for invoke bytecodes. However,
  // stack traversal automatically takes care of preserving arguments for invoke, so
  // this is no longer needed.

  // JRT_END does an implicit safepoint check, hence we are guaranteed to block
  // if this is called during a safepoint

  if (JvmtiExport::should_post_single_step()) {
    // This function is called by the interpreter when single stepping. Such single
    // stepping could unwind a frame. Then, it is important that we process any frames
    // that we might return into.
    StackWatermarkSet::before_unwind(current);

    // We are called during regular safepoints and when the VM is
    // single stepping. If any thread is marked for single stepping,
    // then we may have JVMTI work to do.
    LastFrameAccessor last_frame(current);
    JvmtiExport::at_single_stepping_point(current, last_frame.method(), last_frame.bcp());
  }
JRT_END

总结

从上面的代码分析可以看到，解释执行时，线程进入安全点的方式和编译执行有较大差异；JVM是通过在生成的字节码指令里面增加判断，如果判断当前线程需要进入安全点，则不执行字节码对应的函数指令，转而执行进入安全点指令;

Java threads can be in several different states and arestopped by different mechanisms:

1. Running interpreted
   When executing branching/returning byte codes interpreter
   checks if the poll is armed, if so blocks in SS::block().
2. Running in native code
  When returning from the native code, a Java thread must check
   the safepoint _state to see if we must block.  If the
   VM thread sees a Java thread in native, it does
   not wait for this thread to block.  The order of the memory
   writes and reads of both the safepoint state and the Java
   threads state is critical.  In order to guarantee that the
   memory writes are serialized with respect to each other,
   the VM thread issues a memory barrier instruction.
3. Running compiled Code
   Compiled code reads the local polling page that
   is set to fault if we are trying to get to a safepoint.
4. Blocked
   A thread which is blocked will not be allowed to return from the
  block condition until the safepoint operation is complete.
5. In VM or Transitioning between states
   If a Java thread is currently running in the VM or transitioning
   between states, the safepointing code will poll the thread state
   until the thread blocks itself when it attempts transitions to a
  new state or locking a safepoint checked monitor.