Erlang二进制创建的内部机制和优化（二）

最新推荐文章于 2022-07-21 15:00:00 发布
最新推荐文章于 2022-07-21 15:00:00 发布
阅读量1.4k 收藏
点赞数
分类专栏： Erlang源码分析 文章标签： Erlang C 源码分析 binary 优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhongruixian/article/details/9495453
版权
Erlang二进制创建的内部机制和优化（一）

这一节以实例分析的方式继续探索二进制创建的内部机制。

为了验证上一节的内容，首先在erl_bits.c中的erts_bs_appen函数里加入一些调试输出。 
void print_bin(char *title, unsigned char *data, int len)
{
    Uint index = 0;
    erts_fprintf(stderr,"%s {", title);
    while(index < len){
        if(index) erts_fprintf(stderr,",%u", data[index]);
        else erts_fprintf(stderr,"%u", data[index]);
        index++;
    }
    erts_fprintf(stderr, "} (len:%d)\n", len);
}


Eterm
erts_bs_append(Process* c_p, Eterm* reg, Uint live, Eterm build_size_term,
            Uint extra_words, Uint unit)
{
    Eterm bin; /* Given binary */
    Eterm* ptr;
    Eterm hdr;
    ErlSubBin* sb;
    ProcBin* pb;
    Binary* binp;
    Uint heap_need;
    Uint build_size_in_bits;
    Uint used_size_in_bits;
    Uint unsigned_bits;
    ERL_BITS_DEFINE_STATEP(c_p);


    // 需要创建的二进制的位数: build_size_in_bits
    if (is_small(build_size_term)) {
        Sint signed_bits = signed_val(build_size_term);
        if (signed_bits < 0) {
            goto badarg;
        }
        build_size_in_bits = (Uint) signed_bits;
    } else if (term_to_Uint(build_size_term, &unsigned_bits)) {
        build_size_in_bits = unsigned_bits;
    } else {
        c_p->freason = unsigned_bits;
        return THE_NON_VALUE;
    }


    // 测试输出
    erts_fprintf(stderr,"*** append start *** "
                "build_size_in_bits:%d, heap_top:%p\n", 
                build_size_in_bits, c_p->htop);


    bin = reg[live];
    if (!is_boxed(bin)) {
badarg:
        c_p->freason = BADARG;
        return THE_NON_VALUE;
    }
    ptr = boxed_val(bin);
    // 取出二进制数据流中的header
    hdr = *ptr;
    if (!is_binary_header(hdr)) {
        goto badarg;
    }
    // #MARK_A
    if (hdr != HEADER_SUB_BIN) {
        // 非子二进制，不可写
        erts_fprintf(stderr, "not_sub_bin, not_writable, header:%X\n", hdr);
        // if((hdr & _HEADER_SUBTAG_MASK) == HEAP_BINARY_SUBTAG){
        //     erts_fprintf(stderr, "be_heap_bin, not_writable\n", hdr);
        // }else{
        //     erts_fprintf(stderr, "not_sub_bin, not_writable, header:%X\n", hdr);
        // }
        goto not_writable;
    }
    sb = (ErlSubBin *) ptr;
    if (!sb->is_writable) {
        // is_writable==0，不可写
        erts_fprintf(stderr, "not_writable is_writable==0\n");
        goto not_writable;
    }
    pb = (ProcBin *) boxed_val(sb->orig);
    print_bin("pb->bytes:", (char *)pb->bytes, pb->size);
    
    // 必须是refc binary
    ASSERT(pb->thing_word == HEADER_PROC_BIN);
    if ((pb->flags & PB_IS_WRITABLE) == 0) {
        // 标明了不可写
        erts_fprintf(stderr, "not_writable (pb->flags & PB_IS_WRITABLE) == 0\n");
        goto not_writable;
    }


    /*
     * OK, the binary is writable.
     */


    // 测试输出
    erts_fprintf(stderr, "writable\n");


    erts_bin_offset = 8*sb->size + sb->bitsize;
    if (unit > 1) {
        if ((unit == 8 && (erts_bin_offset & 7) != 0) ||
                    (erts_bin_offset % unit) != 0) {
            goto badarg;
        }
    }
    used_size_in_bits = erts_bin_offset + build_size_in_bits;
    // 原来的sub binary设为不可写，因为后继空间将要被写入数据
    // #MARK_B
    sb->is_writable = 0; /* Make sure that no one else can write. */
    erts_fprintf(stderr, "pb->size: from %ld extend to %ld\n", pb->size, NBYTES(used_size_in_bits));
    // 扩展到所需大小
    pb->size = NBYTES(used_size_in_bits);
    pb->flags |= PB_ACTIVE_WRITER;


    /*
     * Reallocate the binary if it is too small.
     */
    binp = pb->val;
    // 如果容器的空间不足，则重新分配容器大小到所需的二倍
    if (binp->orig_size < pb->size) {
        Uint new_size = 2*pb->size;
        binp = erts_bin_realloc(binp, new_size);
        binp->orig_size = new_size;
        // 注意：重新分配空间以后，pb->val指针会被改变，
        // 所以此用的binary不能被外部引用
        // #MARK_C
        pb->val = binp;
        pb->bytes = (byte *) binp->orig_bytes;
    }
    erts_current_bin = pb->bytes;


    // 测试输出
    erts_fprintf(stderr, "Binary Size:%ld, Binary Refc:%ld\n", binp->orig_size, binp->refc);
    print_bin("new pb->bytes:", (char *)pb->bytes, pb->size);


    /*
     * Allocate heap space and build a new sub binary.
     */
    reg[live] = sb->orig;
    heap_need = ERL_SUB_BIN_SIZE + extra_words;
    if (c_p->stop - c_p->htop < heap_need) {
        (void) erts_garbage_collect(c_p, heap_need, reg, live+1);
    }
    // 创建一个新的sub binary，指向原二进制的开头，
    // 相比原来的sub binary，这里只是把空间大小扩展到所需值
    sb = (ErlSubBin *) c_p->htop; // 从堆顶写入
    // 进程堆顶上升ERL_SUB_BIN_SIZE(20)字节
    c_p->htop += ERL_SUB_BIN_SIZE;
    sb->thing_word = HEADER_SUB_BIN;
    sb->size = BYTE_OFFSET(used_size_in_bits);
    sb->bitsize = BIT_OFFSET(used_size_in_bits);
    sb->offs = 0;
    sb->bitoffs = 0;
    // 最新的sub binary，设为可写
    // 也就是说，在一系列的append操作中，只有最后一个sub binary是可写的
    sb->is_writable = 1;
    sb->orig = reg[live];


    erts_fprintf(stderr, "--- new_sub_binary_ok ---  new_heap_top:%p\n\n", c_p->htop);
    return make_binary(sb);


    /*
     * The binary is not writable. We must create a new writable binary and
     * copy the old contents of the binary.
     */
not_writable:
    {
        Uint used_size_in_bytes; /* Size of old binary + data to be built */
        Uint bin_size;
        Binary* bptr;
        byte* src_bytes;
        Uint bitoffs;
        Uint bitsize;
        Eterm* hp;


        /*
         * Allocate heap space.
         */
        heap_need = PROC_BIN_SIZE + ERL_SUB_BIN_SIZE + extra_words;
        if (c_p->stop - c_p->htop < heap_need) {
            (void) erts_garbage_collect(c_p, heap_need, reg, live+1);
            bin = reg[live];
        }
        hp = c_p->htop;


        /*
         * Calculate sizes. The size of the new binary, is the sum of the
         * build size and the size of the old binary. Allow some room
         * for growing.
         */
        ERTS_GET_BINARY_BYTES(bin, src_bytes, bitoffs, bitsize);
        erts_bin_offset = 8*binary_size(bin) + bitsize;
        if (unit > 1) {
            if ((unit == 8 && (erts_bin_offset & 7) != 0) ||
                        (erts_bin_offset % unit) != 0) {
                goto badarg;
            }
        }
        used_size_in_bits = erts_bin_offset + build_size_in_bits;
        used_size_in_bytes = NBYTES(used_size_in_bits);
        bin_size = 2*used_size_in_bytes;


        // 至少256字节
        bin_size = (bin_size < 256) ? 256 : bin_size;


        /*
         * Allocate the binary data struct itself.
         */
        // 创建大小为所需空间的二倍的binary(最小值为256字节)，
        // 它作为一个容器，存储在进程堆以外，
        // 进程堆里只存放引用这个binary的refc binary
        bptr = erts_bin_nrml_alloc(bin_size);
        bptr->flags = 0;
        bptr->orig_size = bin_size;
        erts_refc_init(&bptr->refc, 1);
        erts_current_bin = (byte *) bptr->orig_bytes;


        erts_fprintf(stderr, "bptr:%p, bin_size:%lu\n", bptr, bin_size);
        /*
         * Now allocate the ProcBin on the heap.
         */
        // 创建refc binary，引用上面的binary, 并存储到进程堆
        pb = (ProcBin *) hp;
        hp += PROC_BIN_SIZE;
        pb->thing_word = HEADER_PROC_BIN;
        // 当前设置为实际所需的大小，以后的append操作可扩展
        pb->size = used_size_in_bytes; 
        pb->next = MSO(c_p).first;
        MSO(c_p).first = (struct erl_off_heap_header*)pb;
        pb->val = bptr;
        pb->bytes = (byte*) bptr->orig_bytes;
        pb->flags = PB_IS_WRITABLE | PB_ACTIVE_WRITER;
        OH_OVERHEAD(&(MSO(c_p)), pb->size / sizeof(Eterm));


        /*
         * Now allocate the sub binary and set its size to include the
         * data about to be built.
         */
        // 创建sub binary，引用上面的refc binary，并设置为所需大小
        sb = (ErlSubBin *) hp;
        hp += ERL_SUB_BIN_SIZE;
        sb->thing_word = HEADER_SUB_BIN;
        sb->size = BYTE_OFFSET(used_size_in_bits);
        sb->bitsize = BIT_OFFSET(used_size_in_bits);
        sb->offs = 0;
        sb->bitoffs = 0;
        sb->is_writable = 1;
        sb->orig = make_binary(pb);


        c_p->htop = hp;


        /*
         * Now copy the data into the binary.
         */


        copy_binary_to_buffer(erts_current_bin, 0, src_bytes, bitoffs, erts_bin_offset);
        // 为了方便测试，仅输出前20字节
        print_bin("dst_bytes:", erts_current_bin, 20);


        erts_fprintf(stderr,"-------- new_heap_top:%p --------\n\n", c_p->htop);
        return make_binary(sb);
    }
}


实例1：在Erlang Shell中演示erlang的binary append操作过程
修改完Erlang C源码后，编译并启动Erlang Shell，运行测试代码： 
Bin0 = <<1>>,
Bin1 = <<Bin0/binary,2>>,
Bin2 = <<Bin1/binary,3>>,
Bin3 = <<Bin1/binary,4>>,
{Bin2,Bin3}.
结果如下(#开头的表示注释)： 
Eshell V5.10.2  (abort with ^G)
1>     Bin0 = <<1>>,
1>     Bin1 = <<Bin0/binary,2>>,
1>     Bin2 = <<Bin1/binary,3>>,
1>     Bin3 = <<Bin1/binary,4>>,
1>     {Bin2,Bin3}.
*** append start *** build_size_in_bits:8, heap_top:0x01b1aa24
not_sub_bin, not_writable, header:64
bptr:0x01c41d18, bin_size:256
dst_bytes: {0,0,196,1,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255} (len:20)
-------- new_heap_top:0x01b1aa50 --------


*** append start *** build_size_in_bits:8, heap_top:0x01b09090
not_sub_bin, not_writable, header:64
bptr:0x01c41d18, bin_size:256
dst_bytes: {1,0,196,1,255,255,15,15,15,15,15,15,15,15,15,15,15,15,15,15} (len:20)
-------- new_heap_top:0x01b090bc --------


*** append start *** build_size_in_bits:8, heap_top:0x01b09164
pb->bytes: {1} (len:1)
writable
pb->size: from 1 extend to 2
Binary Size:256, Binary Refc:1
new pb->bytes: {1,0} (len:2)
--- new_sub_binary_ok ---  new_heap_top:0x01b09178


#上面两段是 Bin1 = <<Bin0/binary, 2>> 执行过程中调用append函数的输出，
#首先看到not_sub_bin，header为64表示它是一个heap binary，不可写。
#接着创建了一个容器binary，大小为256字节，并且复制了Bin0，
#dst_bytes第二字节以后都是可被写的空间，这里看到后面有内容是因为分配空间后没有清0
#申请了binary容器后，继续调用append进行扩展ProcBin的长度，从1扩展到2，用于容纳<<Bin0/binary,2>>


*** append start *** build_size_in_bits:16, heap_top:0x01b1326c
not_sub_bin, not_writable, header:64
bptr:0x01c41e38, bin_size:256
dst_bytes: {255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,170,170,170,170} (len:20)
-------- new_heap_top:0x01b13298 --------


*** append start *** build_size_in_bits:8, heap_top:0x01b13340
pb->bytes: {1,2} (len:2)
writable
pb->size: from 2 extend to 3
Binary Size:256, Binary Refc:1
new pb->bytes: {1,2,255} (len:3)
--- new_sub_binary_ok ---  new_heap_top:0x01b13354


#上面两段是 Bin2 = <<Bin1/binary, 3>> 执行过程中调用append函数的输出，
#仍然看到Bin1被复制后再进行扩展到3字节，
#按上一节内容来说，这是不应该的，这里到底发生了什么？


*** append start *** build_size_in_bits:16, heap_top:0x025bbb58
not_sub_bin, not_writable, header:64
bptr:0x01c41d18, bin_size:256
dst_bytes: {1,2,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15} (len:20)
-------- new_heap_top:0x025bbb84 --------


*** append start *** build_size_in_bits:8, heap_top:0x025bbc2c
pb->bytes: {1,2} (len:2)
writable
pb->size: from 2 extend to 3
Binary Size:256, Binary Refc:1
new pb->bytes: {1,2,15} (len:3)
--- new_sub_binary_ok ---  new_heap_top:0x025bbc40


#上面两段是 Bin3 = <<Bin1/binary, 4>> 执行过程中调用append函数的输出，
#这里的Bin1被复制是正常的，但是，引起复制的原因是not_sub_bin，仍然是heap binary，
#按上一节的内容，这里应该是: not_writable is_writable==0
#为什么Bin1是heap binary？


{<<1,2,3>>,<<1,2,4>>}
实例2：将代码写入文件中编译后测试erlang的binary append操作过程
test.erl 
-module(test).
-export([t/4]).
-export([t/0]).


t() ->
    Bin0 = <<1>>,
    Bin1 = <<Bin0/binary,2>>,
    Bin2 = <<Bin1/binary,3>>,
    Bin3 = <<Bin1/binary,4>>,
    {Bin2,Bin3}.


t(A1, A2, A3, A4) ->
    Bin0 = <<A1>>,
    Bin1 = <<Bin0/binary,A2>>, %% append操作1:Bin0是heap binary，不可写
    Bin2 = <<Bin1/binary,A3>>, %% append操作2:Bin1可写，并设置为以后不可写
    Bin3 = <<Bin1/binary,A4>>, %% append操作3:Bin1不可再写
    {Bin2,Bin3}.
先看看test:t/0 
Eshell V5.10.2  (abort with ^G)
1> test:t().
{<<1,2,3>>,<<1,2,4>>}

发现没有调试输出，猜测是没有调用append函数。

继续看看test:t/4的结果。 
Eshell V5.10.2  (abort with ^G)
1> test:t(1,2,3,4).
*** append start *** build_size_in_bits:8, heap_top:0x01b09598
not_sub_bin, not_writable, header:A4
bptr:0x01c41220, bin_size:256
dst_bytes: {1,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170} (len:20)
-------- new_heap_top:0x01b095c4 --------


*** append start *** build_size_in_bits:8, heap_top:0x01b095c4
pb->bytes: {1,2} (len:2)
writable
pb->size: from 2 extend to 3
Binary Size:256, Binary Refc:1
new pb->bytes: {1,2,170} (len:3)
--- new_sub_binary_ok ---  new_heap_top:0x01b095d8


*** append start *** build_size_in_bits:8, heap_top:0x01b095d8
not_writable is_writable==0
bptr:0x01c40040, bin_size:256
dst_bytes: {1,2,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170} (len:20)
-------- new_heap_top:0x01b09604 --------


{<<1,2,3>>,<<1,2,4>>}
上面三段输出刚好对应代码中的三个append操作，而且结果也和上一节所说的内容一致了。

上面的三个测试结果，让我们产生了很多不解，下面就将这些迷团一一解开。

先将test.erl通过下面的命令编译成erlang 指令。
erlc +\'S\' test.erl

test.S

{function, t, 0, 2}.
  {label,1}.
    {line,[{location,"test.erl",4}]}.
    {func_info,{atom,test},{atom,t},0}.
  {label,2}.
    {move,{literal,{<<1,2,3>>,<<1,2,4>>}},{x,0}}.
    return.




{function, t, 4, 4}.
  {label,3}.
    {line,[{location,"test.erl",11}]}.
    {func_info,{atom,test},{atom,t},4}.
  {label,4}.
    {line,[{location,"test.erl",12}]}.
    {bs_init2,{f,0},1,0,4,{field_flags,[]},{x,4}}.
    {bs_put_integer,{f,0},{integer,8},1,{field_flags,[unsigned,big]},{x,0}}.
    {bs_append,{f,0},{integer,8},0,4,8,{x,4},{field_flags,[]},{x,0}}.
    {bs_put_integer,{f,0},{integer,8},1,{field_flags,[unsigned,big]},{x,1}}.
    {bs_append,{f,0},{integer,8},0,4,8,{x,0},{field_flags,[]},{x,1}}.
    {bs_put_integer,{f,0},{integer,8},1,{field_flags,[unsigned,big]},{x,2}}.
    {bs_append,{f,0},{integer,8},3,4,8,{x,0},{field_flags,[]},{x,2}}.
    {bs_put_integer,{f,0},{integer,8},1,{field_flags,[unsigned,big]},{x,3}}.
    {put_tuple,2,{x,0}}.
    {put,{x,1}}.
    {put,{x,2}}.
    return.
从上面可以看到，test:t/0已经被编译器处理成{<<1,2,3>>,<<1,2,4>>}，故不会再调用append，
而test:t/4是通过参数动态创建的，从中可以看到它调用的函数及执行流程。

最不解的是在Erlang Shell中执行的结果，为什么和预期的相差这么远？

Erlang的二进制append操作过程中，由于ProcBin（见#MARK_C处）所引用的binary在扩展空间时可能会被移动，此时就必段更新ProcBin的引用指针(ProcBin->val)，
如果这时有别的ProcBin引用了这个binary，就可能会出问题，这也违反了变量不可变的原则，

所以，当append操作的过程中，如果出中间执行了一些会影响ProcBin的指令，sub binary就会被设置为以后不可再写。


出现以下情况之一，都会被设为不可再写：
  • 当作结果返回
  • 当作消息被发送（PortOrPid ! Bin1）
  • 当作普通变量插入ETS表
  • 当作普通变量进行二进制匹配操作

在Erlang Shell中，测试代码可以写成这样： 
    Bin0 = <<1>>.
    Bin1 = <<Bin0/binary,2>>.
    Bin2 = <<Bin1/binary,3>>.
    Bin3 = <<Bin1/binary,4>>.
    {Bin2,Bin3}.
这就说明，每一行都像一个函数一样，执行结果将会被返回保存。

例如，在Erlang Shell中，Bin3 = <<Bin1/binary,4>> 这一句的执行过程如下：


先创建一个大小为可以容器Bin1的heap binary： 
// 节选自beam_emu.c
do_bs_init_bits_known:
    // 此处省略N行。。。
    erts_bin_offset = 0;
    erts_writable_bin = 0;
    hb = (ErlHeapBin *) HTOP;
    HTOP += heap_bin_size(num_bytes);
    hb->thing_word = header_heap_bin(num_bytes);
    hb->size = num_bytes;
    erts_current_bin = (byte *) hb->data;
    new_binary = make_binary(hb);
接着进行append操作，最后读取结果： 
// 节选自beam_emu.c
do_bs_get_binary_all_reuse_common:
    orig = mb->orig;
    sb = (ErlSubBin *) boxed_val(context_to_binary_context);
    hole_size = 1 + header_arity(sb->thing_word) - ERL_SUB_BIN_SIZE;
    sb->thing_word = HEADER_SUB_BIN;
    sb->size = BYTE_OFFSET(size);
    sb->bitsize = BIT_OFFSET(size);
    sb->offs = BYTE_OFFSET(offs);
    sb->bitoffs = BIT_OFFSET(offs);
    // 设为不可写
    sb->is_writable = 0;
    sb->orig = orig;
    if (hole_size) {
        sb[1].thing_word = make_pos_bignum_header(hole_size-1);
    }
    // ...
由于Erlang Shell中每一行的执行结果都会被返回保存，所以打断了append连续优化的操作，出现了不是我们预期的结果。

小结
  1. 在Erlang编程中，我们要了解Binary二进制的创建场情是否会发挥append的优化特性，特别是在网络编程中的收包解包，要充分利用这一特性以提高效率。
  2. 编译器会对erl代码进行优化，测试时要注意这种优化是否会影响测试结果。
  3. Erlang Shell中执行代码时，要了解它的执程流程及与文件代码的区别，以免出现莫名的情况。
  4. erl代码可以通过erlc +\'E\' file.erl和erlc +\'S\' file.erl生成代码的扩展文件和指令文件，观察程序执行过程。
瑞仙
关注
专栏目录
使用 Go 语言实现高性能网络服务: 包括TCP连接管理、内存池、epoll、缓存设计、序列化等
AI天才研究院
08-07 1626
Go 是一门开源的编程语言，由 Google 开发并于 2009 年正式发布。静态强类型:在编译时已经把变量的数据类型确定下来，并进行严格类型检查；自动垃圾回收:不需要手动分配和释放内存，通过引用计数实现自动释放无用对象；接口:支持接口、多态特性，可以方便地实现依赖注入、适配器模式、代理模式等；goroutine:采用协程（Coroutine）机制，使得编写异步并发程序变得简单；cgo:可以调用 C/C++ 的库函数，通过 cgo 可以直接利用现有的第三方库；
Erlang二进制创建的内部机制和优化（一）
844604778
07-26 169
《Erlang Binary的内部结构和分类介绍》一文是本文的基础，接下来要探讨的是构建Binary时，什么情景下才能充分发挥Erlang运行时系统对二进制创建做所做的优化特性。 下面是引用官方文档中的一个例子，并加予C源码进一步阐述二进制创建的内部机制。Bin0 = &lt;&lt;0&gt;&gt;, %% 1 Bin1 = &lt;&lt;Bin0/b...
erlang的二进制使用学习
iteye_2227的博客
12-23 284
最近因工作要求，需要使用erlang编程语言进行程序开发，不过一直没 有机会应用erlang的二进制使用，个人感觉erlang的二进制功能很强大， 但是里面有些知识点比较拗口，一不小心就模糊了相关的使用规则，下 面列出其使用方式以备忘记：   1.将一个整数强制拆分成指定长度的二进制表示：   1&gt;Bin =  &lt;&lt;17:15&gt;&gt;.   &lt;&...
erlang中的错误处理
Erlang Display - Erlang问答社区：www.erlangqa.com
01-13 301
erlang中错误大体分为四种： 1. 编译错误 2. 逻辑错误 3. 运行时错误 4. 用户代码生成的错误 编译错误，主要是编译器检测出的代码语法错误 逻辑错误，是指程序没有完成预期的工作，属于开发人员的问题 运行时错误，是指erlang运行时抛出的错误，比如对非数据类型执行算术运算，erlang运行时会捕获异常，并抛出。在erlang中，这类异常的...
Rabbitmq安装过程和踩过的坑( 一 安装 )
运维呆子 的博客
07-14 1万+
基于rabiitmq 3.7.7 +erl 21.0.0版本安装   1、首先上来先改HOSTS 先hostname 查看本机hostname，然后加上去： vim /etc/hosts 127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4 ::1         localhost...
Concurrent Programming in ERLANG (P1-90)
10-18
这包括但不限于整数、浮点数、原子、列表、元组、二进制数据、PID等。了解这些术语对于理解Erlang程序的执行过程至关重要。 **2.2 模式匹配** 模式匹配是Erlang中的一个重要特性，它允许开发者在函数定义中使用...
Erlang Reference Manual
01-09
位串和二进制数据类型允许开发者以位级别进行操作，这对于网络编程或处理二进制数据非常重要。手册中详细解释了这两种数据类型的使用方法和应用场景。 **1.2.5 引用(Reference)** 引用是一种由运行时系统生成的...
otp_src_23.0.tar.gz rabbitmq3.9.9.zip
11-22
解压"rabbitmq3.9.9.zip"后，用户将获得RabbitMQ服务器的二进制文件和必要的配置文件。安装过程通常包括设置环境变量、启动服务、配置服务器参数等。RabbitMQ通常通过管理界面或命令行工具进行管理，如管理插件的...
Apache Thrift微服务RPC框架与性能优化指南
Thrift是一种接口描述语言(IDL)和二进制通信协议，用于定义和创建跨语言的服务接口和数据类型。它的目的是简化网络服务的开发。安装Thrift通常需要下载源码并使用编译器进行编译安装。 2. Thrift数据类型与IDL理解...
windows上部署rabbitmq遇到的一些问题及解决方法
weixin_30951389的博客
09-17 1583
在目前这家公司，刚进公司的时候接手了一个服务，算是个比较完备的服务，其中几台电脑之间通信用到了rabbitmq，一开始没出什么问题，然后后来勒索病毒wanner cry来的时候，系服把所有服务器装了一个什么杀毒软件，重启之后rabibtmq集群就出现了一些问题，经过一番学习，把这些问题都搞定了，现在做一个总结。 　　一开始，我按照官网的描述，把四台服务器加入了一个集群，但是不知道为...
Windows10下 安装使用RabbitMQ遇到的特别报错以及各种试错解决方案
Set sail again
07-21 1790
　软件环境Windows10家庭版Erlang版本24.0 RabbitMQServer 3.8.19 安装方式网上随意可以搜到比如：　https://blog.csdn.net/weixin_43876186/article/details/108344733 总体步骤为：安装Erlang 配置Erlang系统环境变量并添加到path中验证是否安装成功cm...
windows RabbitMQ service install 失败
饭桶一生奋斗
11-13 4263
报错问题: C:\Program Files\erl5.10.3\erts-5.10.3\bin\erlsrv: Warning, could not set correct service description (comment)Error: 句柄无效(有时乱码)。 解决方式: 1、卸载erlang 2、去注册表里HKLM/SOFTWARE/Ericsson/Erlang/ErlSrv下的项清掉
WIN10 下的erlang + rabbitmq安装，以及遇到的问题
霸王龙i的博客
11-29 1万+
本文主要记录一次WIN10环境下的erlang+rabbitmq的安装。 erlang 19.3(8.3) rabbltmq 3.7.6
Android 打印机----》使用android串口以及ESC/POS指令进行小票打印
qq_36561118的博客
07-30 3245
开发环境 Android studio 3.5.1 gradle版本3.5.1 android 编译版本 28 jdk1.8 win7 开发准备 对android 串口通信有一定了解 对ESC/POS指令有一定了解 串口 下载google的串口demohttps://code.google.com/archive/p/android-serialport-api/source/default/source 集成演示 将google串口demo中的...
[erlang入门学习] erlang中的二进制数据处理
自由天堂的博客
06-30 753
在网络编程中，我们面对的不再是字符串，而是字节流，对于这些信息的处理，erlang提供了比特语法这样的工具。   废话少说，看例子：   Eshell V5.8.4 (abort with ^G) 1&gt; X = "hello".   先定义一个字符串变量X，下面把它变成二进制数据 2&gt; BinX = list_to_binary("hello"). &lt;&lt;...
9.Erlang 二进制操作
LYY的学习和记录
02-26 762
一，为什么使用二进制类型？ 使用低级别的编程更加可靠，而且相比于元组和列表更加节省空间。有时候大量结构化的数据必须在计算机之间相互移动，我们就需要确保数据尽可能高效传播，利用一切可以存储的位置，每个位置尽可能含有较多的信息。 二，二进制类型 1.内置函数转化二进制 1>A={test,1,2,3,[1,2,3]}. {test,1,2,3,[1,2,3]} 2> Bin1=t...
Erlang list的++操作和append函数的底层实现
铿锵玫瑰的专栏
08-27 1493
当提到Erlang中list的++操作符时，我们常会想到它的性能问题。 有些人知道++操作比较耗时，就改用函数append来代替。 到底++操作和append函数之间有什么区别？ 我们来查看一下它们在Erlang源码及C源码中的实现。 在$ERL_TOP/lib/stdlib/src/lists.erl可以找到如下代码： [plain] view plai
Erlang的crypto模块与最新的openssl动态链接库不兼容的问题与解决方案
热门推荐
Rolong的博客
01-06 1万+
CentOS 6.3 64位，装完Erlang后，出现了crypto模块使用不正常的情况，开始猜测是最新版本的openssl的动态链接库有问题，也请教了余峰老大，叫我在centos 6.2环境下测试一下，于是在一台老服务器上编译当前最新版的erlang R16B03，没有出现问题，但是，用yum更新了OpenSSL后，同样的问题出现了。 新版本的openssl编译出来的动态链接库的问题？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值