假設是少量的switch case，全然能夠接受，可是對於虛擬機來說。有著成百上千的switch case，並且運行頻繁非常高，運行一條指令就須要一次線性搜索。確定比較耗性能。假設能直接跳轉到運行代碼位置，就能夠省去線性搜索的過程了。於是在字節碼的分派方式上，做了新的改進。這項技術叫作 Context Threading（上下文線索化技術。Thread眼下都沒有合適的中文翻譯。我這裏意譯為線索化。表示當中的線索關系）。

這裏取了Context Threading論文的樣例，說明上下文線索化技術（Context Threading）1.首先，代碼會被編譯成字節碼
2.假設是switch派發指令，效率低下
3.假設是線索化代碼（Threaded Code），就直接跳轉（goto），無需多次switch
4.從字節碼到終於運行代碼的過程。

左邊是編譯生成的字節碼，中間就是字節碼載入後生成的線索化代碼，右邊是相應的虛擬機實現代碼。虛擬機運行時，vpc指向了iload_1指令，在運行iload_1指令操作後依據goto *vpc++ 跳轉到下一條指令地址。繼續運行，如此重復。這個過程就好像穿針引線。每運行完一條指令，就直接跳轉到下一條指令的地址。而不再是Switch Loop那樣，每運行一條指令都要做一次switch。（這裏，vPC是指虛擬PC指令。在erlang中是IP指針）

拓展閱讀

BIF（內建函數）

erlang源碼編譯時生成bif函數表信息。見 erts\emulator\<machine>\erl_bif_table.c

Export* bif_export[BIF_SIZE];
BifEntry bif_table[] = {
    {am_erlang, am_abs, 1, abs_1, abs_1},
    {am_erlang, am_adler32, 1, adler32_1, wrap_adler32_1},
    {am_erlang, am_adler32, 2, adler32_2, wrap_adler32_2},
    {am_erlang, am_adler32_combine, 3, adler32_combine_3, wrap_adler32_combine_3},
    {am_erlang, am_apply, 3, apply_3, wrap_apply_3},
    {am_erlang, am_atom_to_list, 1, atom_to_list_1, wrap_atom_to_list_1},

typedef struct bif_entry {
    Eterm module;
    Eterm name;
    int arity;
    BifFunction f;  // bif函數
    BifFunction traced;  // 函數調用跟蹤函數
} BifEntry;

init_emulator:
{
     
     em_call_error_handler = OpCode(call_error_handler);
     em_apply_bif = OpCode(apply_bif);

     beam_apply[0] = (BeamInstr) OpCode(i_apply);
     beam_apply[1] = (BeamInstr) OpCode(normal_exit);
     beam_exit[0] = (BeamInstr) OpCode(error_action_code);
     beam_continue_exit[0] = (BeamInstr) OpCode(continue_exit);
     beam_return_to_trace[0] = (BeamInstr) OpCode(i_return_to_trace);
     beam_return_trace[0] = (BeamInstr) OpCode(return_trace);
     beam_exception_trace[0] = (BeamInstr) OpCode(return_trace); /* UGLY */
     beam_return_time_trace[0] = (BeamInstr) OpCode(i_return_time_trace);

     /*
      * Enter all BIFs into the export table.
      */
     for (i = 0; i < BIF_SIZE; i++) {
         ep = erts_export_put(bif_table[i].module, //模塊名
         bif_table[i].name,
         bif_table[i].arity);
         bif_export[i] = ep;
         ep->code[3] = (BeamInstr) OpCode(apply_bif);
         ep->code[4] = (BeamInstr) bif_table[i].f;  // BIF函數
         /* XXX: set func info for bifs */
         ep->fake_op_func_info_for_hipe[0] = (BeamInstr) BeamOp(op_i_func_info_IaaI);
     }

/*
 * 下面截取 bif 處理過程
 */
OpCase(call_bif_e):
    {
 Eterm (*bf)(Process*, Eterm*, BeamInstr*) = GET_BIF_ADDRESS(Arg(0)); // 依據參數獲取bif實際運行函數
 Eterm result;
 BeamInstr *next;
 PRE_BIF_SWAPOUT(c_p);
 c_p->fcalls = FCALLS - 1;
 if (FCALLS <= 0) {
    save_calls(c_p, (Export *) Arg(0));
 }
 PreFetch(1, next);
 ASSERT(!ERTS_PROC_IS_EXITING(c_p));
 reg[0] = r(0);
 result = (*bf)(c_p, reg, I); // 運行bif函數
 ASSERT(!ERTS_PROC_IS_EXITING(c_p) || is_non_value(result));
 ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
 ERTS_HOLE_CHECK(c_p);
 ERTS_SMP_REQ_PROC_MAIN_LOCK(c_p);
 PROCESS_MAIN_CHK_LOCKS(c_p);
 if (c_p->mbuf || MSO(c_p).overhead >= BIN_VHEAP_SZ(c_p)) {
     Uint arity = ((Export *)Arg(0))->code[2];
     result = erts_gc_after_bif_call(c_p, result, reg, arity);
     E = c_p->stop;
 }
 HTOP = HEAP_TOP(c_p);
 FCALLS = c_p->fcalls;
 if (is_value(result)) {
     r(0) = result;
     CHECK_TERM(r(0));
     NextPF(1, next);
 } else if (c_p->freason == TRAP) { 
     SET_CP(c_p, I+2);
     SET_I(c_p->i);
     SWAPIN;
     r(0) = reg[0];
     Dispatch();
}

#define GET_BIF_ADDRESS(p) ((BifFunction) (((Export *) p)->code[4]))

擴展指令集

erlang虛擬機代碼運行原理