erlang虚拟机代码运行原理

最新推荐文章于 2023-06-07 08:40:52 发布
最新推荐文章于 2023-06-07 08:40:52 发布
阅读量225 收藏
点赞数
文章标签： 运维 shell 操作系统
erlang是开源的，非常多人都研究过源码。可是。从erlang代码到c代码。这是个不小的跨度。并且代码也比較复杂。

所以这里，我利用一些时间，整理下erlang代码的运行过程。从erlang代码编译过程，到代码运行过程做解说。然后重点讲下虚拟机运行代码的原理。

将本篇文章。献给全部喜欢erlang的人。


erlang代码编译过程

erlang对开发人员是友好的。从erlang程序文件编译成能被erlang虚拟机识别的beam文件，在这个编译过程还对开发人员暴露中间代码。借助这个中间代码，我们就能够逐步探究erlang代码的运行过程。


这是erlnag的编译过程，当然，最開始和大多数编译器一样，首先会将程序文件转换成语法树，但这个转换对我们来说阅读的意义不大，所以归结于以上3个过程。


1. erlang核心代码
确切的叫法是Core Erlang，使用了相似Haskell 的语法，每一个变量都用“Let” 声明。在erlang shell通过下面方式能够获取模块的Core Erlang代码。将会生成test.core文件
c(test, to_core).
实际上core文件能够直接编译成beam文件。例如以下：
c(test, from_core).

2. erlang汇编码
这个是erlang代码编译成beam前的汇编代码，尽管在erlang打包成beam。以及载入到VM时会进一步优化。但汇编码实际上能够看成erlang代码到c代码的纽带。但理解汇编码而不是非常easy，这里要知道erlang VM的设计基于寄存器。当中有两类重要的寄存器，传递參数的x寄存器。和在函数内用作本地变量的y寄存器。在erlang shell通过下面方式能够获取模块的汇编代码，将会生成test.S文件
c(test, to_asm). 或是 c(test, 'S').
当然，S文件也支持编译成beam文件，例如以下：
c(test, from_asm).

3. erlang BEAM
beam文件是不可阅读的，仅仅是给VM识别，内容包括了代码。原子，导入导出函数，属性，编译信息等数据块。

4.  erlang运行时代码
运行时代码是指模块载入到VM后的代码，erlang对开发人员暴露了底层的接口。

当模块载入后，在erlang shell下通过下面方式能够获取模块的运行时代码。就会生成test.dis文件

erts_debug:df(test).

这里。细心的同学会发现，通过对照erlang汇编码和运行时代码，发现指令代码是不全然相同的。一方面。erlang会对指令进一步做优化。另外。erlang使用了两种指令集，有限指令集和扩展指令集，在beam文件使用了有限指令集。然后在载入到VM时展开为扩展指令集。

有论文说是为了降低Beam的大小，这点我没有做过实质性的探究，我仅仅是认为有限指令集比較短，更easy阅读被人理解。关于有限指令集和扩展指令集的区别。我在文章最后的拓展阅读做了讨论。


erlang代码从编译到运行过程

前面介绍了erlang代码编译的过程。如今再来说明erlang代码从编译到运行的完整过程。

文章erlang版本号以R16B02作说明。


这里。erlang代码先被编译成beam。然后载入到VM中，最后再被模拟器所识别和调用。

当中。beam文件的载入过程会将beam的字节码形式的数据转成 Threaded code和数据。 前面也提到，beam文件的字节码数据包括有代码块，这里是将指令展开，转成Threaded code（线索化代码），每条指令包括了opcode（操作码）和operands（操作数），另外还对 operands 做修正。比方调用 外部 函数。这里会找到这个外部函数的导出地址，这样每次代码运行的时候就不用再去函数表查找到这个函数，就能够直接运行代码。

Beam的载入逻辑是在 beam_load.c 完毕的，指令集的转换在beam_opcodes.c做了映射，而beam_opcodes.c文件是在编译Erlang源码过程有Perl脚本beam_makeops依据ops.tab生成的。全部有限指令集能够在genop.tab找到。
File 
Path
beam_makeops
erts/emulator/utils/
ops.tab
erts/emulator/beam/
beam_opcodes.c
erts/emulator/<machine>/opt/smp/
beam_load.c
erts/emulator/beam/
genop.tab
lib/compiler/src/


erlang 虚拟机运行代码的原理

这里先简单说明下erlang虚拟机、进程、堆栈。寄存器，然后側重从指令调度。代码线索化说明虚拟机代码运行原理。

erlang虚拟机概述

通常我们说的eralng虚拟机。是指BEAM虚拟机模拟器和erlang运行时系统（ERTS）。

ERTS是erlang VM最底层的应用，负责和操作系统交互，管理I/O，实现erlang进程和BIF函数。BEAM模拟器是运行Erlang程序经编译后产出的字节码的地方。

erlang虚拟机最早的版本号是Joe Armstrong编写的，基于栈，叫JAM(Joe's Abstract Machine)，非常相似 WAM（Warren's Abstract Machine）。

后来改成基于寄存器的虚拟机，也就是如今的BEAM（Bogdan's Abstract Machine），运行效率有了较大幅度提升。这在Joe的erlang VM演变论文有说到。


基于栈和基于寄存器的虚拟机有什么区别？

基于栈（stack-based）的虚拟机的指令长度是固定的。运行多个操作数计算时。会先将操作数做压入栈。由运算指令取出并计算。

而基于寄存器（register-based）的指令长度不是固定的，能够在指令中带多个操作数。这样，基于寄存器能够降低指令数量，降低入栈出栈操作，从而降低了指令派发的次数和内存訪问的次数，相比开销少了非常多。

可是，假设利用寄存器做数据交换，就要常常保存和恢复寄存器的结果。这就导致基于寄存器的虚拟机在实现上要比基于栈的复杂，代码编译也要复杂得多


erlang进程

erlang进程是在代码运行过程中动态创建和销毁。每一个进程都有自己私有的栈和堆。erlang进程是erlang虚拟机进行资源分配和调度的基本单位。erlang代码的运行要通过erlang进程来实现。
1> spawn(fun() -> m:loop() end).
<0.34.0>
也许有人会问，启动erlang节点时没有使用不论什么进程。这是为什么？ 实际上。启动erlang节点的代码是运行在shell进程。相同受到erlang虚拟机调度。我们看到的是由shell进程运行后返回的结果。

为了实现多进程并发。erlang虚拟机实现了进程挂起和调度机制。进程运行代码时会消耗调度次数（Reductions），当调度次数为0时就会挂起这个进程，然后从调度队列中取出第一个进程运行。

假设进程在等待新消息时也会被挂起，直到这个进程接收到新消息后。就又一次加到调度队列。



进程的栈和堆

erlang进程在运行代码的过程中。栈主要用来存放调用帧的本地变量和返回地址。堆则是用来存放运行过程创建的数据。在实现上，栈和堆是在同一个内存区域的。例如以下图：

堆栈的内存空间是先申请一块较大的内存后一点一点使用。不够再又一次申请一大块。这样避免频繁申请释放内存造成开销。以上，在已分配好的内存区域内，堆从最低的地址向上增长，而栈从最高的地址向下增长。中间堆顶和栈顶的空白区域。表示了进程堆栈还未使用到的空间，使用内存时就向里收缩，不够时就运行gc。这样，内存溢出检查就仅仅要比較栈顶和堆顶就好。
堆用于存储复杂的数据结构，如元组。列表或大整数。

栈被用来存储简单的数据，还有指向堆中复杂数据的数据指针。

栈有指针指向堆，但不会有指针从堆到栈。


寄存器

前面也提到。对于基于栈的虚拟机。操作数在使用前都会被压到栈，计算时取出。也就是先将本地变量的值压入栈。然后在计算时从栈取出赋值给本地变量。所以，这里有非常大开销在本地变量和栈之间的交换上（出入栈）。

为此，基于寄存器的虚拟机使用暂时变量来保存这个本地变量，这个暂时变量也就是寄存器。并且，这个寄存器变量通常都被优化成CPU的寄存器变量，这样，虚拟机訪问寄存器变量甚至都不用訪问内存。极大的提高了系统的运行速度。

    /*
     * X register zero; also called r(0)
     */
    register Eterm x0 REG_x0 = NIL;
register修饰符的作用是暗示编译器。某个变量将被频繁使用，尽可能将其保存在CPU的寄存器中，以加快其存储速度。随着编译程序设计技术的进步，在决定那些变量应该被存到寄存器中时。如今的编译器能比程序猿做出更好的决定，往往会忽略register修饰符。

可是就erlang虚拟机对寄存器变量的使用程度，应该是能够利用到CPU寄存器的优点。


erlang有哪些寄存器？
參数寄存器（R0-R1024） R0是最快的。是独立的寄存器变量，其它以reg[N]訪问。R0还用来保存函数返回值
指令寄存器（IP） 引用当前正在运行的指令，能够通过I[N]取到上下文指令。

返回地址寄存器 （CP。原意Continuation Pointer） 记录当前函数调用的返回地址，在运行完当前函数后返回上一个函数中断处运行后面的代码。
栈寄存器（EP） 指向栈的栈顶。以E[N]数组形式訪问栈帧数据
堆寄存器 （heap top）指向堆的堆顶，以HTOP[N]数组形式訪问堆数据
暂时寄存器（tmp_arg1和tmp_arg2）用于指令实现须要暂时变量的场合（尽可能重用暂时变量，同一时候利用CPU寄存器优化）
浮点寄存器（FR0-FR15）

其它寄存器：
'Live' 表示当前须要的寄存器数量，非常多指令取这个值来推断是否要运行GC申请新的空间
'FCALLS' 表示当前进程剩余的调度次数（Reductions）

若不考虑多调度器，寄存器是全部进程共享的。当虚拟机调度运行某个进程的时候，寄存器就归这个进程使用。

当进程被调出的时候，寄存器就给其它进程使用。（进程切换保存进程上下文时。仅仅须要保存指令寄存器IP和当前函数信息。效率非常高）


指令调度

erlang指令调度实现是一个巨大的switch结构。每一个case语句都相应一个指令操作码（opcode）。这样就能够实现指令的分发和运行。可是。switch调度方式实现简单。但效率比較低下。所以。erlang虚拟机使用了goto语法，避免过多的使用switch造成性能损耗。同一时候，erlang还使用跳转表，在一些高级编译器下（如GCC） 。利用label-goto语法。效率比較高（针对跳转表的概念。我之前也有文章说明。见 这里）。正由于这点，虚拟机调度时解释指令的代价不容忽视，基于寄存器的虚拟机指令少，就要比基于栈高效。 
while(1){
 opcode = *vPC++;
 switch(opcode){
   case i_call_fun:
          ..
       break;
   case call_bif_e:
          ..
       break;
 //and many more..
 }
};
字节码在虚拟机中运行。运行过程相似CPU运行指令过程，分为取指，解码。运行3个过程。通常情况下，每一个操作码相应一段处理函数，然后通过一个无限循环加一个switch的方式进行分派。


erlang进程创建时必须指定运行函数，进程创建后就会运行这个函数。从这个函数開始一直到结束，进程都会被erlang虚拟机调度。 

start()->
   spawn(fun() -> fun1(1) end).  %% 创建进程。运行 fun1/1

fun1(A) ->
   A1 = A + 1,
   B = trunc(A1),  %% 运行 trunc/1
   {ok, A1+B}.
以上。进程在运行函数 （  trunc/1 ） 调用 前。会将当前的本地变量和返回地址指针CP写入栈。然后，在运行完这个函数（trunc/1 ）后再从栈取出CP指令和本地变量，依据CP指针返回调用处，继续运行后面的代码。


这样，每次函数运行结束时，erlang从栈顶检查并取得CP指针（假设函数内过于简单，没有其它函数调用，就直接读取 (Process* c_p)->cp），然后 将CP指针的值赋给指令寄存器IP，同一时候删除CP栈帧（依据须要还要回收Live借用的栈空间），继续调度运行。
备注：这里讲到的栈帧删除操作，如CP指针。本地变量数据。删除时仅仅要将栈顶指针向高位移动N个位置，没有GC操作，代价极小。另外，这里也显露出一个问题，假设非尾递归函数调用。erlang须要重复将本地变量和CP指针入栈。easy触发GC和内存复制，引发内存抖动。


另外，在寄存器方面，函数调用时，erlang虚拟机会将传參写到參数寄存器x(N)，然后更新返回地址寄存器CP。在函数调用返回时，会将返回值写到x(0)寄存器。

Threaded Code（线索化代码）

前面提到switch指令派发方式，每次处理完一条指令后，都要回到循环的開始，处理下一条指令。可是，每次switch操作，都可能是一次线性搜索（现代编译器能对switch语句进行优化。 以消除这样的线性搜索开销，但也是仅仅限于特定条件。如case的数量和值的跨度范围等）。

假设是少量的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（内建函数）

BIF是erlang的内建函数，由C代码实现，用以实如今erlang层面实现效率不高或无法实现的功能。大多数BIF函数属于erlang模块，也有其它模块的BIF函数。ets或lists，os等
1> erlang:now().
{1433,217791,771000}
2> lists:member(1,[1,2,3]).
true

这里重点解释下。 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;
erlang BEAM模拟器启动时会初始化bif函数表， 
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函数编译后，opcode都是 call_bif_e，操作数是函数导出表地址，下面分析下这个opcode的实现： 
/*
 * 下面截取 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();
}
上面涉及到一个宏，就是取得bif函数地址。 

#define GET_BIF_ADDRESS(p) ((BifFunction) (((Export *) p)->code[4]))
依据前面提到的。( (Export *) p)->code[4] 就是  bif_table表的中BIF函数的地址。

扩展指令集

BEAM文件使用的是有限指令集（limited instruction set），这些指令集会在beam文件被载入时，展开为扩展指令集（extended instruction set）。
get_list -> get_list_rrx
get_list ->get_list_rry
call_bif -> call_bif_e

扩展指令集和有限指令集的区别是，扩展指令集还描写叙述了操作数类型。
TypeDescription
tAn arbitrary term, e.g. {ok,[]}
IAn integer literal, e.g. 137
xA register, e.g. R1
yA stack slot
cAn immediate term, i.e. atom/small int/nil
aAn atom, e.g. 'ok'
fA code label
sEither a literal, a register or a stack slot
dEither a register or a stack slot
rA register R0
PA unsigned integer literal
jAn optional code label
eA reference to an export table entry
lA floating-point register
以  call_bif_e 为例， e表示了操作数为函数导出表地址。所以 call_bif_e 能够这样取到bif代码地址
 ((Export *) Arg(0))->code[4]

文献资料：
[2]  Virtual Machine Showdown: Stack Versus Registers Yunhe Shi, David Gregg, Andrew Beatty
[3]  Context Threading: A flexible and efficient dispatch technique for virtual machine interpreters

參考：
http://blog.csdn.net/mycwq/article/details/45653897
weixin_34400525
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Erlang服务器代码的分析与学习（一）
Cheng_1992的博客
08-19 537
The Echo process -module(echo). -export([go/0, loop/0]). go() -> Pid = spawn(echo, loop, []), Pid ! {self(), hello}, receive {Pid, Msg} -> io:format("~w~n",[Msg]) end, Pid ! stop. loop() ->
erlang vm 内存分布整理
u013456128的博客
06-07 1476
此文章仅代表个人的见解，有不对之处，希望朋友予以纠正。 [erlang alloc] Erlang Vm底层申请内存有两种方式。 1： malloc调用。通过操作系统的malloc调用，主要用于堆栈的内存申请。 2： mseg调用。用于向操作系统申请缓冲块，以页为单位。不会出现半页的情况。刚好与操作系统的缓冲块相吻合。 erlts_alloc is an Erlang R
Erlang编译并运行程序
weixin_48321067的博客
04-27 485
当系统尝试调用的函数属于一个尚未加载的模块时，就会出现一个异常，系统会尝试寻找缺 失模块的对象代码文件。如果缺失的模块名为Module，代码载入器就会在当前载入路 径的所有目录里搜索一个名为Module.beam的文件。只要找到相符的文件，搜索就会 停止，此文件的目标代码会被载入系统。这样一定可以准确无误的找到程序，但是，随着程序变得越来越复 杂，我们需要把它放在不同的文件包中，那么我们应该怎么去加载它们。这 就要用到makefile。c(模块名)，进行编译，在使用模块名：方法名进行运行。
Erlang虚拟机(VM)简介
844604778
07-27 348
Erlang代码是运行在Erlang的虚拟机(VM)上的，所谓虚拟，说它是虚拟一台真实的机器，还不如说它是虚拟了一个运行Erlang指令的CPU来得更确切。 Erlang运行在虚拟机上，就好比C语言运行在真实的机器上。 Erlang语言的代码在编译时，也有中间的汇编代码，了解它的汇编指令，可以进一步理解Erlang代码在VM里的运行机制。 下面我们就把Erlang的Beam模拟器看作是一个C...
erlang语言详解并推荐入门书籍(10本)
记录 IT 领域经验与见解的博客
06-07 2288
Erlang是一种函数式编程语言，它旨在用于高可靠性、分布式、并发的系统。Erlang最初是由爱立信公司的Joe Armstrong等人开发的，用于管理电话交换机系统，具有高可靠性和容错能力。Erlang的语法基于模式匹配和递归，使用虚拟机运行，可以提供轻量级进程和分布式消息传递机制，支持OTP（开放式电信平台）。虚拟机Erlang运行于虚拟机BEAM（Bogdan/Björn's Erlang Abstract Machine），它是一个高度优化的虚拟机，可以提供实时垃圾回收和进程调度机制。
erlang---启动参数学习/研究
mochinoname的专栏
07-18 7896
原文见于%erlang安装目录%/erts-版本号/doc/html/erl.html erlang启动参数有3种：emulator flags, flags 和plain arguments。emulator flags 是以“+”开头的，用来控制模拟器的行为。flags 是以
Erlang模块与Erlang程序的运行方法
cloveses的专栏
10-13 6116
一、模块与程序文件     Erlang是一种函数式编程语言，当我们要完成一个项目时，总不可能把所有的函数都定义在一个程序文件中，为了开发和维护方便，通常按逻辑功能划分将其分别分散在多个程序文件中。     每个Erlang程序文件就是一个模块，文件名的扩展名部分为.erl，模块的名称必须与文件名称中的主文件名完全相同（不包括扩展名.erl）。     在Erlang程序文件中，用以下模
Erlang虚拟机内存管理
03-16
Erlang核心开发者Lukas Larsson在2014年3月份Erlang Factory上的一个演讲详细介绍了Erlang内存体系的原理以及调优案例 根据siyao zheng博客上听写的资源进行的翻译，大致只翻译了80%但核心部分已经完整，希望对大家...
远古封神+英雄远征的ERLANG游戏服务器代码
12-09
看到另外两个分好高，我把另外两个二合一啦。远古封神+英雄远征的ERLANG游戏服务器代码，看过了，感觉不错的。
KMP（Erlang）代码实现
02-22
kmp游戏中使用频率较高，所以用erlang代码代码实现，效率还行。
theBeamBook:Erlang运行时系统ERTS和虚拟机BEAM的描述
04-30
BEAM书这是尝试记录Erlang运行时系统和称为BEAM的Erlang虚拟机的内部信息。 您可以从以PDF格式阅读或下载该书，也可以从阅读或下载。 这本书是用AsciiDoc编写的，大部分内容都可以在浏览器中直接从GitHub上的源代码...
Erlang高级应用和原理
09-09
erlang的一些高级特性(gen_server CouchDB etc..)应用场景成功案例
基于Erlang VM的语言
01-06
基于Erlang VM的语言基于Erlang基于Erlang VM的语言 VM的语言基于Erlang VM的语言
hex, Erlang虚拟机的软件包管理器.zip
10-10
hex, Erlang虚拟机的软件包管理器 十六进制 Hex是Erlang虚拟机的软件包管理器。这个项目目前提供了与混合。tcm 工具构建的任务。有关安装说明和其他文档，请参阅 hex.pm 。在本地安装十六进制以进行开发： mix ...
运行Erlang的程序
我相信......
03-06 7367
运行Erlang程序的方式： 1) 在Erlang shell 中编译执行 2) Shell 脚本执行，例 Hello.sh #!/bin/sh Erl –noshell –pa /home/abel/practice/erlang/code –s hllstart –s init stop 3) 作为Escript 运行，例 #!/usr/bin/env escript Main(args)-> Io:format(“Hello world ~n”)
Erlang port driver工作原理
枯树无花
05-11 417
与其说erlang是一个语言运行环境，不如说它是一个虚拟的操作系统环境。在这个操作系统环境下运行着虚拟的erlang process，这些process之间是独立并行运行的，由erlang虚拟机负责调度，就像在真的操作系统中一样。作为虚拟的操作系统，当然少不了对io的处理。这些虚拟的process需要虚拟的io设备来和外界通信。Port在整个erlang环境中就扮演了这个角色。 在erlang中，一个Port其实就代表了一个io句柄。一个process通过open_port打开一个port，然后在这个po
Erlang原理2
好记性不如烂博客
11-03 128
进程组、任务和JCL（Process group, Jobs and JCL） As Erlang evolved there was the idea that Erlang was, in many ways, like an operating system, not just a language running within an OS. One result of this...
erlang 架构原理_Erlang与Java内存架构
最佳 Java 编程
05-29 269
erlang 架构原理 我读了一篇关于Erlang VM的内存管理策略的非常非常有趣的文章。 它是Jesper Wilhelmsson撰写的论文 ，我认为讨论Erlang的内存设置和Oracle的Java VM之间的差异可能会很好。 作为对从未听说过Erlang的人们的一个简短的介绍; 它是一种功能语言，使用异步消息传递作为并发的基础。 消息传递使用复制语义，从而可以在不止一台机器上运行的多...
【erlang】入门篇
陈戏猿
03-05 1173
欢迎入坑erlang，erlang是一种高并发，容错和分布式的函数式编程语言。本文详细介绍了erlang的安装和开发环境，如何使用erlang shell，以及如何运行erlang代码，既可以在erlang shell中运行，也可以在命令行中运行，也可以作为脚本运行。最后是关于erlang中一些语法约定。
erlang安装运行找不到erl命令
最新发布
07-28
请确保按照上述步骤正确设置ERLANG_HOME，并重新运行安装程序。\[1\]\[2\] #### 引用[.reference_title] - *1* *2* [Windows Server 安装Erlang以及无法识别erl命令解决方法]...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值