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

《Erlang Binary的内部结构和分类介绍》一文是本文的基础，接下来要探讨的是构建Binary时，什么情景下才能充分发挥Erlang运行时系统对二进制创建做所做的优化特性。


下面是引用官方文档中的一个例子，并加予C源码进一步阐述二进制创建的内部机制。

Bin0 = <<0>>,                    %% 1
Bin1 = <<Bin0/binary,1,2,3>>,    %% 2
Bin2 = <<Bin1/binary,4,5,6>>,    %% 3
Bin3 = <<Bin2/binary,7,8,9>>,    %% 4
Bin4 = <<Bin1/binary,17>>,       %% 5 !!!
{Bin4,Bin3}                      %% 6

在第一行，系统创建了一个堆二进制(heap binary)。
在《Erlang Binary的内部结构和分类介绍》已经提到，堆二进制被直接存储到进程堆里，最大为64字节，如果大于64字节，引用计数二进制(refc binary)将会被创建。


第二行属于二进制的append操作，调用了erl_bits.c中的erts_bs_appen函数，C源码及注解如下：

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;
    }


    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) {
        // 非子二进制，不可写
        goto not_writable;
    }
    sb = (ErlSubBin *) ptr;
    if (!sb->is_writable) {
        // is_writable==0，不可写
        goto not_writable;
    }
    pb = (ProcBin *) boxed_val(sb->orig);
    
    // 必须是refc binary
    ASSERT(pb->thing_word == HEADER_PROC_BIN);
    if ((pb->flags & PB_IS_WRITABLE) == 0) {
        // 标明了不可写
        goto not_writable;
    }


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


    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. */
    // 扩展到所需大小
    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不能被外部引用
        pb->val = binp;
        pb->bytes = (byte *) binp->orig_bytes;
    }
    erts_current_bin = pb->bytes;


    /*
     * 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];


    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;


        /*
         * 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);
        return make_binary(sb);
    }
}

从上面代码#MARK_A处可以看到，如果不是子二进制(sub binary)就跳到not_writable，然后创建所需要的容器、refc binary和sub binary，并拷贝Bin0的内容(详细请看not_writable部分中的注释)，为append做准备。

Bin0 = <<0>>,                    %% 1
Bin1 = <<Bin0/binary,1,2,3>>,    %% 2
Bin2 = <<Bin1/binary,4,5,6>>,    %% 3
Bin3 = <<Bin2/binary,7,8,9>>,    %% 4
Bin4 = <<Bin1/binary,17>>,       %% 5 !!!
{Bin4,Bin3}                      %% 6

在第三行，由于Bin1是最后一个执行过append操作的，它的后继空间是自由的，是可被扩展的，而且，Bin1不可能再被改变，
所以Bin1不会被复制，只是在Bin1的后面依次追加1、2、3，

第四行的执行过程和第三行一样。

在第五行，是往Bin1后面追加数据，而不是Bin3。由于Bin1已经不是最后被执行过append操作的数据，即Bin1的后继空间已经有别的数据存在（此处Bin1后面已经保存了4,5,6,7,8,9）。所以执行过程不会和上面两行一样。在这里将会创建新的sub binary并拷贝Bin1，然后在它的后面追加17。

我们是怎么知道它后面不能再追加数据？文档中也有这么一个问题：
We will not explain here how the run-time system can know that it is not allowed to write into Bin1; it is left as an exercise to the curious reader to figure out how it is done by reading the emulator sources, primarily erl_bits.c.

这个问题的答案，上面append函数中可以找到。其实在执行第三行时，Bin1已被设置为不可写（参见#MARK_B处）。

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