自学教程：C++ ATB_GET_KIND函数代码示例

// force the freeing of a piece of memoryvoid gc_free(void *ptr_in) {    if (gc_lock_depth > 0) {        // TODO how to deal with this error?        return;    }    mp_uint_t ptr = (mp_uint_t)ptr_in;    DEBUG_printf("gc_free(%p)/n", ptr);    if (VERIFY_PTR(ptr)) {        mp_uint_t block = BLOCK_FROM_PTR(ptr);        if (ATB_GET_KIND(block) == AT_HEAD) {            // set the last_free pointer to this block if it's earlier in the heap            if (block / BLOCKS_PER_ATB < gc_last_free_atb_index) {                gc_last_free_atb_index = block / BLOCKS_PER_ATB;            }            // free head and all of its tail blocks            do {                ATB_ANY_TO_FREE(block);                block += 1;            } while (ATB_GET_KIND(block) == AT_TAIL);            #if EXTENSIVE_HEAP_PROFILING            gc_dump_alloc_table();            #endif        }    }}

// force the freeing of a piece of memory// TODO: freeing here does not call finaliservoid gc_free(void *ptr) {    if (MP_STATE_MEM(gc_lock_depth) > 0) {        // TODO how to deal with this error?        return;    }    DEBUG_printf("gc_free(%p)/n", ptr);    if (VERIFY_PTR(ptr)) {        size_t block = BLOCK_FROM_PTR(ptr);        if (ATB_GET_KIND(block) == AT_HEAD) {            #if MICROPY_ENABLE_FINALISER            FTB_CLEAR(block);            #endif            // set the last_free pointer to this block if it's earlier in the heap            if (block / BLOCKS_PER_ATB < MP_STATE_MEM(gc_last_free_atb_index)) {                MP_STATE_MEM(gc_last_free_atb_index) = block / BLOCKS_PER_ATB;            }            // free head and all of its tail blocks            do {                ATB_ANY_TO_FREE(block);                block += 1;            } while (ATB_GET_KIND(block) == AT_TAIL);            #if EXTENSIVE_HEAP_PROFILING            gc_dump_alloc_table();            #endif        } else {            assert(!"bad free");        }    } else if (ptr != NULL) {        assert(!"bad free");    }}

void gc_dump_alloc_table(void) {    mp_uint_t bl;    static const mp_uint_t DUMP_BYTES_PER_LINE = 64;    #if !EXTENSIVE_HEAP_PROFILING    // When comparing heap output we don't want to print the starting    // pointer of the heap because it changes from run to run.    printf("GC memory layout; from %p:", gc_pool_start);    #endif    for (bl = 0; bl < gc_alloc_table_byte_len * BLOCKS_PER_ATB; bl++) {        if (bl % DUMP_BYTES_PER_LINE == 0) {            // a new line of blocks            #if EXTENSIVE_HEAP_PROFILING            {                // check if this line contains only free blocks                bool only_free_blocks = true;                for (mp_uint_t bl2 = bl; bl2 < gc_alloc_table_byte_len * BLOCKS_PER_ATB && bl2 < bl + DUMP_BYTES_PER_LINE; bl2++) {                    if (ATB_GET_KIND(bl2) != AT_FREE) {                        only_free_blocks = false;                        break;                    }                }                if (only_free_blocks) {                    // line contains only free blocks, so skip printing it                    bl += DUMP_BYTES_PER_LINE - 1;                    continue;                }            }            #endif            // print header for new line of blocks            printf("/n%04x: ", (uint)bl);        }        int c = ' ';        switch (ATB_GET_KIND(bl)) {            case AT_FREE: c = '.'; break;            case AT_HEAD: c = 'h'; break;            /* this prints the uPy object type of the head block            case AT_HEAD: {                mp_uint_t *ptr = gc_pool_start + bl * WORDS_PER_BLOCK;                if (*ptr == (mp_uint_t)&mp_type_tuple) { c = 'T'; }                else if (*ptr == (mp_uint_t)&mp_type_list) { c = 'L'; }                else if (*ptr == (mp_uint_t)&mp_type_dict) { c = 'D'; }                else if (*ptr == (mp_uint_t)&mp_type_float) { c = 'F'; }                else if (*ptr == (mp_uint_t)&mp_type_fun_bc) { c = 'B'; }                else { c = 'h'; }                break;            }            */            case AT_TAIL: c = 't'; break;            case AT_MARK: c = 'm'; break;        }        printf("%c", c);    }    printf("/n");}

// force the freeing of a piece of memoryvoid gc_free(void *ptr_in) {    machine_uint_t ptr = (machine_uint_t)ptr_in;    if (VERIFY_PTR(ptr)) {        machine_uint_t block = BLOCK_FROM_PTR(ptr);        if (ATB_GET_KIND(block) == AT_HEAD) {            // free head and all of its tail blocks            do {                ATB_ANY_TO_FREE(block);                block += 1;            } while (ATB_GET_KIND(block) == AT_TAIL);        }    }}

size_t gc_nbytes(const void *ptr) {    if (VERIFY_PTR(ptr)) {        size_t block = BLOCK_FROM_PTR(ptr);        if (ATB_GET_KIND(block) == AT_HEAD) {            // work out number of consecutive blocks in the chain starting with this on            size_t n_blocks = 0;            do {                n_blocks += 1;            } while (ATB_GET_KIND(block + n_blocks) == AT_TAIL);            return n_blocks * BYTES_PER_BLOCK;        }    }    // invalid pointer    return 0;}

void gc_dump_alloc_table(void) {    printf("GC memory layout; from %p:", gc_pool_start);    for (machine_uint_t bl = 0; bl < gc_alloc_table_byte_len * BLOCKS_PER_ATB; bl++) {        if (bl % 64 == 0) {            printf("/n%04x: ", (uint)bl);        }        int c = ' ';        switch (ATB_GET_KIND(bl)) {            case AT_FREE: c = '.'; break;            case AT_HEAD: c = 'h'; break;            /* this prints the uPy object type of the head block            case AT_HEAD: {                machine_uint_t *ptr = gc_pool_start + bl * WORDS_PER_BLOCK;                if (*ptr == (machine_uint_t)&mp_type_tuple) { c = 'T'; }                else if (*ptr == (machine_uint_t)&mp_type_list) { c = 'L'; }                else if (*ptr == (machine_uint_t)&mp_type_dict) { c = 'D'; }                else if (*ptr == (machine_uint_t)&mp_type_float) { c = 'F'; }                else if (*ptr == (machine_uint_t)&mp_type_fun_bc) { c = 'B'; }                else { c = 'h'; }                break;            }            */            case AT_TAIL: c = 't'; break;            case AT_MARK: c = 'm'; break;        }        printf("%c", c);    }    printf("/n");}

// force the freeing of a piece of memoryvoid gc_free(void *ptr_in) {    if (gc_lock_depth > 0) {        // TODO how to deal with this error?        return;    }    machine_uint_t ptr = (machine_uint_t)ptr_in;    if (VERIFY_PTR(ptr)) {        machine_uint_t block = BLOCK_FROM_PTR(ptr);        if (ATB_GET_KIND(block) == AT_HEAD) {            // free head and all of its tail blocks            do {                ATB_ANY_TO_FREE(block);                block += 1;            } while (ATB_GET_KIND(block) == AT_TAIL);        }    }}

STATIC void gc_sweep(void) {    #if MICROPY_PY_GC_COLLECT_RETVAL    MP_STATE_MEM(gc_collected) = 0;    #endif    // free unmarked heads and their tails    int free_tail = 0;    for (size_t block = 0; block < MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB; block++) {        switch (ATB_GET_KIND(block)) {            case AT_HEAD:#if MICROPY_ENABLE_FINALISER                if (FTB_GET(block)) {                    mp_obj_base_t *obj = (mp_obj_base_t*)PTR_FROM_BLOCK(block);                    if (obj->type != NULL) {                        // if the object has a type then see if it has a __del__ method                        mp_obj_t dest[2];                        mp_load_method_maybe(MP_OBJ_FROM_PTR(obj), MP_QSTR___del__, dest);                        if (dest[0] != MP_OBJ_NULL) {                            // load_method returned a method, execute it in a protected environment                            #if MICROPY_ENABLE_SCHEDULER                            mp_sched_lock();                            #endif                            mp_call_function_1_protected(dest[0], dest[1]);                            #if MICROPY_ENABLE_SCHEDULER                            mp_sched_unlock();                            #endif                        }                    }                    // clear finaliser flag                    FTB_CLEAR(block);                }#endif                free_tail = 1;                DEBUG_printf("gc_sweep(%p)/n", PTR_FROM_BLOCK(block));                #if MICROPY_PY_GC_COLLECT_RETVAL                MP_STATE_MEM(gc_collected)++;                #endif                // fall through to free the head            case AT_TAIL:                if (free_tail) {                    ATB_ANY_TO_FREE(block);                    #if CLEAR_ON_SWEEP                    memset((void*)PTR_FROM_BLOCK(block), 0, BYTES_PER_BLOCK);                    #endif                }                break;            case AT_MARK:                ATB_MARK_TO_HEAD(block);                free_tail = 0;                break;        }    }}

STATIC void gc_dump_at(void) {    for (machine_uint_t bl = 0; bl < gc_alloc_table_byte_len * BLOCKS_PER_ATB; bl++) {        printf("block %06u ", bl);        switch (ATB_GET_KIND(bl)) {            case AT_FREE: printf("FREE"); break;            case AT_HEAD: printf("HEAD"); break;            case AT_TAIL: printf("TAIL"); break;            default: printf("MARK"); break;        }        printf("/n");    }}

STATIC void gc_deal_with_stack_overflow(void) {    while (MP_STATE_MEM(gc_stack_overflow)) {        MP_STATE_MEM(gc_stack_overflow) = 0;        // scan entire memory looking for blocks which have been marked but not their children        for (size_t block = 0; block < MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB; block++) {            // trace (again) if mark bit set            if (ATB_GET_KIND(block) == AT_MARK) {                gc_mark_subtree(block);            }        }    }}

// Take the given block as the topmost block on the stack. Check all it's// children: mark the unmarked child blocks and put those newly marked// blocks on the stack. When all children have been checked, pop off the// topmost block on the stack and repeat with that one.STATIC void gc_mark_subtree(size_t block) {    // Start with the block passed in the argument.    size_t sp = 0;    for (;;) {        // work out number of consecutive blocks in the chain starting with this one        size_t n_blocks = 0;        do {            n_blocks += 1;        } while (ATB_GET_KIND(block + n_blocks) == AT_TAIL);        // check this block's children        void **ptrs = (void**)PTR_FROM_BLOCK(block);        for (size_t i = n_blocks * BYTES_PER_BLOCK / sizeof(void*); i > 0; i--, ptrs++) {            void *ptr = *ptrs;            if (VERIFY_PTR(ptr)) {                // Mark and push this pointer                size_t childblock = BLOCK_FROM_PTR(ptr);                if (ATB_GET_KIND(childblock) == AT_HEAD) {                    // an unmarked head, mark it, and push it on gc stack                    TRACE_MARK(childblock, ptr);                    ATB_HEAD_TO_MARK(childblock);                    if (sp < MICROPY_ALLOC_GC_STACK_SIZE) {                        MP_STATE_MEM(gc_stack)[sp++] = childblock;                    } else {                        MP_STATE_MEM(gc_stack_overflow) = 1;                    }                }            }        }        // Are there any blocks on the stack?        if (sp == 0) {            break; // No, stack is empty, we're done.        }        // pop the next block off the stack        block = MP_STATE_MEM(gc_stack)[--sp];    }}

void gc_collect_root(void **ptrs, size_t len) {    for (size_t i = 0; i < len; i++) {        void *ptr = ptrs[i];        if (VERIFY_PTR(ptr)) {            size_t block = BLOCK_FROM_PTR(ptr);            if (ATB_GET_KIND(block) == AT_HEAD) {                // An unmarked head: mark it, and mark all its children                TRACE_MARK(block, ptr);                ATB_HEAD_TO_MARK(block);                gc_mark_subtree(block);            }        }    }}

STATIC void gc_deal_with_stack_overflow(void) {    while (gc_stack_overflow) {        gc_stack_overflow = 0;        gc_sp = gc_stack;        // scan entire memory looking for blocks which have been marked but not their children        for (machine_uint_t block = 0; block < gc_alloc_table_byte_len * BLOCKS_PER_ATB; block++) {            // trace (again) if mark bit set            if (ATB_GET_KIND(block) == AT_MARK) {                *gc_sp++ = block;                gc_drain_stack();            }        }    }}

STATIC void gc_sweep(void) {    mp_uint_t block;    #if MICROPY_PY_GC_COLLECT_RETVAL    gc_collected = 0;    #endif    // free unmarked heads and their tails    int free_tail = 0;    for (block = 0; block < gc_alloc_table_byte_len * BLOCKS_PER_ATB; block++) {        switch (ATB_GET_KIND(block)) {            case AT_HEAD:#if MICROPY_ENABLE_FINALISER                if (FTB_GET(block)) {                    mp_obj_t obj = (mp_obj_t)PTR_FROM_BLOCK(block);                    if (((mp_obj_base_t*)obj)->type != MP_OBJ_NULL) {                        // if the object has a type then see if it has a __del__ method                        mp_obj_t dest[2];                        mp_load_method_maybe(obj, MP_QSTR___del__, dest);                        if (dest[0] != MP_OBJ_NULL) {                            // load_method returned a method                            mp_call_method_n_kw(0, 0, dest);                        }                    }                    // clear finaliser flag                    FTB_CLEAR(block);                }#endif                free_tail = 1;                #if MICROPY_PY_GC_COLLECT_RETVAL                gc_collected++;                #endif                // fall through to free the head                // no break - disable eclipse static analyzer warning - intentional fall through            case AT_TAIL:                if (free_tail) {                    DEBUG_printf("gc_sweep(%p)/n",PTR_FROM_BLOCK(block));                    ATB_ANY_TO_FREE(block);                }                break;            case AT_MARK:                ATB_MARK_TO_HEAD(block);                free_tail = 0;                break;        }    }}

void gc_info(gc_info_t *info) {    mp_uint_t block, len;    info->total = (gc_pool_end - gc_pool_start) * sizeof(mp_uint_t);    info->used = 0;    info->free = 0;    info->num_1block = 0;    info->num_2block = 0;    info->max_block = 0;    for (block = 0, len = 0; block < gc_alloc_table_byte_len * BLOCKS_PER_ATB; block++) {        mp_uint_t kind = ATB_GET_KIND(block);        if (kind == AT_FREE || kind == AT_HEAD) {            if (len == 1) {                info->num_1block += 1;            } else if (len == 2) {                info->num_2block += 1;            }            if (len > info->max_block) {                info->max_block = len;            }        }        switch (kind) {            case AT_FREE:                info->free += 1;                len = 0;                break;            case AT_HEAD:                info->used += 1;                len = 1;                break;            case AT_TAIL:                info->used += 1;                len += 1;                break;            case AT_MARK:                // shouldn't happen                break;        }    }    info->used *= BYTES_PER_BLOCK;    info->free *= BYTES_PER_BLOCK;}

STATIC void gc_drain_stack(void) {    while (gc_sp > gc_stack) {        // pop the next block off the stack        machine_uint_t block = *--gc_sp;        // work out number of consecutive blocks in the chain starting with this one        machine_uint_t n_blocks = 0;        do {            n_blocks += 1;        } while (ATB_GET_KIND(block + n_blocks) == AT_TAIL);        // check this block's children        machine_uint_t *scan = (machine_uint_t*)PTR_FROM_BLOCK(block);        for (machine_uint_t i = n_blocks * WORDS_PER_BLOCK; i > 0; i--, scan++) {            machine_uint_t ptr2 = *scan;            VERIFY_MARK_AND_PUSH(ptr2);        }    }}

STATIC void gc_drain_stack(void) {    while (MP_STATE_MEM(gc_sp) > MP_STATE_MEM(gc_stack)) {        // pop the next block off the stack        size_t block = *--MP_STATE_MEM(gc_sp);        // work out number of consecutive blocks in the chain starting with this one        size_t n_blocks = 0;        do {            n_blocks += 1;        } while (ATB_GET_KIND(block + n_blocks) == AT_TAIL);        // check this block's children        void **ptrs = (void**)PTR_FROM_BLOCK(block);        for (size_t i = n_blocks * BYTES_PER_BLOCK / sizeof(void*); i > 0; i--, ptrs++) {            void *ptr = *ptrs;            VERIFY_MARK_AND_PUSH(ptr);        }    }}

STATIC void gc_sweep(void) {    // free unmarked heads and their tails    int free_tail = 0;    for (machine_uint_t block = 0; block < gc_alloc_table_byte_len * BLOCKS_PER_ATB; block++) {        switch (ATB_GET_KIND(block)) {            case AT_HEAD:                free_tail = 1;                // fall through to free the head            case AT_TAIL:                if (free_tail) {                    ATB_ANY_TO_FREE(block);                }                break;            case AT_MARK:                ATB_MARK_TO_HEAD(block);                free_tail = 0;                break;        }    }}

STATIC void gc_sweep(void) {    // free unmarked heads and their tails    int free_tail = 0;    for (machine_uint_t block = 0; block < gc_alloc_table_byte_len * BLOCKS_PER_ATB; block++) {        switch (ATB_GET_KIND(block)) {            case AT_HEAD:#if MICROPY_ENABLE_FINALISER                if (FTB_GET(block)) {                    mp_obj_t obj = (mp_obj_t)PTR_FROM_BLOCK(block);                    if (((mp_obj_base_t*)obj)->type != MP_OBJ_NULL) {                        // if the object has a type then see if it has a __del__ method                        mp_obj_t dest[2];                        mp_load_method_maybe(obj, MP_QSTR___del__, dest);                        if (dest[0] != MP_OBJ_NULL) {                            // load_method returned a method                            mp_call_method_n_kw(0, 0, dest);                        }                    }                    // clear finaliser flag                    FTB_CLEAR(block);                }#endif                free_tail = 1;                // fall through to free the head            case AT_TAIL:                if (free_tail) {                    ATB_ANY_TO_FREE(block);                }                break;            case AT_MARK:                ATB_MARK_TO_HEAD(block);                free_tail = 0;                break;        }    }}

void gc_dump_alloc_table(void) {    static const mp_uint_t DUMP_BYTES_PER_LINE = 64;    #if !EXTENSIVE_HEAP_PROFILING    // When comparing heap output we don't want to print the starting    // pointer of the heap because it changes from run to run.    printf("GC memory layout; from %p:", gc_pool_start);    #endif    for (mp_uint_t bl = 0; bl < gc_alloc_table_byte_len * BLOCKS_PER_ATB; bl++) {        if (bl % DUMP_BYTES_PER_LINE == 0) {            // a new line of blocks            #if EXTENSIVE_HEAP_PROFILING            {                // check if this line contains only free blocks                bool only_free_blocks = true;                for (mp_uint_t bl2 = bl; bl2 < gc_alloc_table_byte_len * BLOCKS_PER_ATB && bl2 < bl + DUMP_BYTES_PER_LINE; bl2++) {                    if (ATB_GET_KIND(bl2) != AT_FREE) {                        only_free_blocks = false;                        break;                    }                }                if (only_free_blocks) {                    // line contains only free blocks, so skip printing it                    bl += DUMP_BYTES_PER_LINE - 1;                    continue;                }            }            #endif            // print header for new line of blocks            printf("/n%04x: ", (uint)bl);        }        int c = ' ';        switch (ATB_GET_KIND(bl)) {            case AT_FREE: c = '.'; break;            case AT_HEAD: c = 'h'; break;            /* this prints out if the object is reachable from BSS or STACK (for unix only)            case AT_HEAD: {                extern char __bss_start, _end;                extern char *stack_top;                c = 'h';                void **ptrs = (void**)&__bss_start;                mp_uint_t len = ((mp_uint_t)&_end - (mp_uint_t)&__bss_start) / sizeof(mp_uint_t);                for (mp_uint_t i = 0; i < len; i++) {                    mp_uint_t ptr = (mp_uint_t)ptrs[i];                    if (VERIFY_PTR(ptr) && BLOCK_FROM_PTR(ptr) == bl) {                        c = 'B';                        break;                    }                }                if (c == 'h') {                    ptrs = (void**)&c;                    len = ((mp_uint_t)stack_top - (mp_uint_t)&c) / sizeof(mp_uint_t);                    for (mp_uint_t i = 0; i < len; i++) {                        mp_uint_t ptr = (mp_uint_t)ptrs[i];                        if (VERIFY_PTR(ptr) && BLOCK_FROM_PTR(ptr) == bl) {                            c = 'S';                            break;                        }                    }                }                break;            }            */            /* this prints the uPy object type of the head block            case AT_HEAD: {                mp_uint_t *ptr = gc_pool_start + bl * WORDS_PER_BLOCK;                if (*ptr == (mp_uint_t)&mp_type_tuple) { c = 'T'; }                else if (*ptr == (mp_uint_t)&mp_type_list) { c = 'L'; }                else if (*ptr == (mp_uint_t)&mp_type_dict) { c = 'D'; }                else if (*ptr == (mp_uint_t)&mp_type_float) { c = 'F'; }                else if (*ptr == (mp_uint_t)&mp_type_fun_bc) { c = 'B'; }                else { c = 'h'; }                break;            }            */            case AT_TAIL: c = 't'; break;            case AT_MARK: c = 'm'; break;        }        printf("%c", c);    }    printf("/n");}

void *gc_realloc(void *ptr_in, machine_uint_t n_bytes) {    if (gc_lock_depth > 0) {        return NULL;    }    // check for pure allocation    if (ptr_in == NULL) {        return gc_alloc(n_bytes, false);    }    machine_uint_t ptr = (machine_uint_t)ptr_in;    // sanity check the ptr    if (!VERIFY_PTR(ptr)) {        return NULL;    }    // get first block    machine_uint_t block = BLOCK_FROM_PTR(ptr);    // sanity check the ptr is pointing to the head of a block    if (ATB_GET_KIND(block) != AT_HEAD) {        return NULL;    }    // compute number of new blocks that are requested    machine_uint_t new_blocks = (n_bytes + BYTES_PER_BLOCK - 1) / BYTES_PER_BLOCK;    // get the number of consecutive tail blocks and    // the number of free blocks after last tail block    // stop if we reach (or are at) end of heap    machine_uint_t n_free   = 0;    machine_uint_t n_blocks = 1; // counting HEAD block    machine_uint_t max_block = gc_alloc_table_byte_len * BLOCKS_PER_ATB;    while (block + n_blocks + n_free < max_block) {        if (n_blocks + n_free >= new_blocks) {            // stop as soon as we find enough blocks for n_bytes            break;        }        byte block_type = ATB_GET_KIND(block + n_blocks + n_free);        switch (block_type) {            case AT_FREE: n_free++; continue;            case AT_TAIL: n_blocks++; continue;            case AT_MARK: assert(0);        }        break;    }    // return original ptr if it already has the requested number of blocks    if (new_blocks == n_blocks) {        return ptr_in;    }    // check if we can shrink the allocated area    if (new_blocks < n_blocks) {        // free unneeded tail blocks        for (machine_uint_t bl = block + new_blocks; ATB_GET_KIND(bl) == AT_TAIL; bl++) {            ATB_ANY_TO_FREE(bl);        }        return ptr_in;    }    // check if we can expand in place    if (new_blocks <= n_blocks + n_free) {        // mark few more blocks as used tail        for (machine_uint_t bl = block + n_blocks; bl < block + new_blocks; bl++) {            assert(ATB_GET_KIND(bl) == AT_FREE);            ATB_FREE_TO_TAIL(bl);        }        // zero out the additional bytes of the newly allocated blocks (see comment above in gc_alloc)        memset((byte*)ptr_in + n_bytes, 0, new_blocks * BYTES_PER_BLOCK - n_bytes);        return ptr_in;    }    // can't resize inplace; try to find a new contiguous chain    void *ptr_out = gc_alloc(n_bytes,#if MICROPY_ENABLE_FINALISER        FTB_GET(block)#else        false#endif    );    // check that the alloc succeeded    if (ptr_out == NULL) {        return NULL;    }    DEBUG_printf("gc_realloc(%p -> %p)/n", ptr_in, ptr_out);    memcpy(ptr_out, ptr_in, n_blocks * BYTES_PER_BLOCK);    gc_free(ptr_in);    return ptr_out;}

void gc_info(gc_info_t *info) {    GC_ENTER();    info->total = MP_STATE_MEM(gc_pool_end) - MP_STATE_MEM(gc_pool_start);    info->used = 0;    info->free = 0;    info->max_free = 0;    info->num_1block = 0;    info->num_2block = 0;    info->max_block = 0;    bool finish = false;    for (size_t block = 0, len = 0, len_free = 0; !finish;) {        size_t kind = ATB_GET_KIND(block);        switch (kind) {            case AT_FREE:                info->free += 1;                len_free += 1;                len = 0;                break;            case AT_HEAD:                info->used += 1;                len = 1;                break;            case AT_TAIL:                info->used += 1;                len += 1;                break;            case AT_MARK:                // shouldn't happen                break;        }        block++;        finish = (block == MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB);        // Get next block type if possible        if (!finish) {            kind = ATB_GET_KIND(block);        }        if (finish || kind == AT_FREE || kind == AT_HEAD) {            if (len == 1) {                info->num_1block += 1;            } else if (len == 2) {                info->num_2block += 1;            }            if (len > info->max_block) {                info->max_block = len;            }            if (finish || kind == AT_HEAD) {                if (len_free > info->max_free) {                    info->max_free = len_free;                }                len_free = 0;            }        }    }    info->used *= BYTES_PER_BLOCK;    info->free *= BYTES_PER_BLOCK;    GC_EXIT();}

void gc_dump_alloc_table(void) {    static const size_t DUMP_BYTES_PER_LINE = 64;    #if !EXTENSIVE_HEAP_PROFILING    // When comparing heap output we don't want to print the starting    // pointer of the heap because it changes from run to run.    mp_printf(&mp_plat_print, "GC memory layout; from %p:", MP_STATE_MEM(gc_pool_start));    #endif    for (size_t bl = 0; bl < MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB; bl++) {        if (bl % DUMP_BYTES_PER_LINE == 0) {            // a new line of blocks            {                // check if this line contains only free blocks                size_t bl2 = bl;                while (bl2 < MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB && ATB_GET_KIND(bl2) == AT_FREE) {                    bl2++;                }                if (bl2 - bl >= 2 * DUMP_BYTES_PER_LINE) {                    // there are at least 2 lines containing only free blocks, so abbreviate their printing                    mp_printf(&mp_plat_print, "/n       (%u lines all free)", (uint)(bl2 - bl) / DUMP_BYTES_PER_LINE);                    bl = bl2 & (~(DUMP_BYTES_PER_LINE - 1));                    if (bl >= MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB) {                        // got to end of heap                        break;                    }                }            }            // print header for new line of blocks            // (the cast to uint32_t is for 16-bit ports)            #if EXTENSIVE_HEAP_PROFILING            mp_printf(&mp_plat_print, "/n%05x: ", (uint)((bl * BYTES_PER_BLOCK) & (uint32_t)0xfffff));            #else            mp_printf(&mp_plat_print, "/n%05x: ", (uint)(PTR_FROM_BLOCK(bl) & (uint32_t)0xfffff));            #endif        }        int c = ' ';        switch (ATB_GET_KIND(bl)) {            case AT_FREE: c = '.'; break;            /* this prints out if the object is reachable from BSS or STACK (for unix only)            case AT_HEAD: {                c = 'h';                void **ptrs = (void**)(void*)&mp_state_ctx;                mp_uint_t len = offsetof(mp_state_ctx_t, vm.stack_top) / sizeof(mp_uint_t);                for (mp_uint_t i = 0; i < len; i++) {                    mp_uint_t ptr = (mp_uint_t)ptrs[i];                    if (VERIFY_PTR(ptr) && BLOCK_FROM_PTR(ptr) == bl) {                        c = 'B';                        break;                    }                }                if (c == 'h') {                    ptrs = (void**)&c;                    len = ((mp_uint_t)MP_STATE_VM(stack_top) - (mp_uint_t)&c) / sizeof(mp_uint_t);                    for (mp_uint_t i = 0; i < len; i++) {                        mp_uint_t ptr = (mp_uint_t)ptrs[i];                        if (VERIFY_PTR(ptr) && BLOCK_FROM_PTR(ptr) == bl) {                            c = 'S';                            break;                        }                    }                }                break;            }            */            /* this prints the uPy object type of the head block */            case AT_HEAD: {                void **ptr = (void**)(MP_STATE_MEM(gc_pool_start) + bl * BYTES_PER_BLOCK);                if (*ptr == &mp_type_tuple) { c = 'T'; }                else if (*ptr == &mp_type_list) { c = 'L'; }                else if (*ptr == &mp_type_dict) { c = 'D'; }                #if MICROPY_PY_BUILTINS_FLOAT                else if (*ptr == &mp_type_float) { c = 'F'; }                #endif                else if (*ptr == &mp_type_fun_bc) { c = 'B'; }                else if (*ptr == &mp_type_module) { c = 'M'; }                else {                    c = 'h';                    #if 0                    // This code prints "Q" for qstr-pool data, and "q" for qstr-str                    // data.  It can be useful to see how qstrs are being allocated,                    // but is disabled by default because it is very slow.                    for (qstr_pool_t *pool = MP_STATE_VM(last_pool); c == 'h' && pool != NULL; pool = pool->prev) {                        if ((qstr_pool_t*)ptr == pool) {                            c = 'Q';                            break;                        }                        for (const byte **q = pool->qstrs, **q_top = pool->qstrs + pool->len; q < q_top; q++) {                            if ((const byte*)ptr == *q) {                                c = 'q';                                break;                            }                        }                    }                    #endif                }                break;            }            case AT_TAIL: c = 't'; break;            case AT_MARK: c = 'm'; break;        }        mp_printf(&mp_plat_print, "%c", c);//.........这里部分代码省略.........

void *gc_realloc(void *ptr_in, size_t n_bytes, bool allow_move) {    if (MP_STATE_MEM(gc_lock_depth) > 0) {        return NULL;    }    // check for pure allocation    if (ptr_in == NULL) {        return gc_alloc(n_bytes, false);    }    // check for pure free    if (n_bytes == 0) {        gc_free(ptr_in);        return NULL;    }    void *ptr = ptr_in;    // sanity check the ptr    if (!VERIFY_PTR(ptr)) {        return NULL;    }    // get first block    size_t block = BLOCK_FROM_PTR(ptr);    // sanity check the ptr is pointing to the head of a block    if (ATB_GET_KIND(block) != AT_HEAD) {        return NULL;    }    // compute number of new blocks that are requested    size_t new_blocks = (n_bytes + BYTES_PER_BLOCK - 1) / BYTES_PER_BLOCK;    // Get the total number of consecutive blocks that are already allocated to    // this chunk of memory, and then count the number of free blocks following    // it.  Stop if we reach the end of the heap, or if we find enough extra    // free blocks to satisfy the realloc.  Note that we need to compute the    // total size of the existing memory chunk so we can correctly and    // efficiently shrink it (see below for shrinking code).    size_t n_free   = 0;    size_t n_blocks = 1; // counting HEAD block    size_t max_block = MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB;    for (size_t bl = block + n_blocks; bl < max_block; bl++) {        byte block_type = ATB_GET_KIND(bl);        if (block_type == AT_TAIL) {            n_blocks++;            continue;        }        if (block_type == AT_FREE) {            n_free++;            if (n_blocks + n_free >= new_blocks) {                // stop as soon as we find enough blocks for n_bytes                break;            }            continue;        }        break;    }    // return original ptr if it already has the requested number of blocks    if (new_blocks == n_blocks) {        return ptr_in;    }    // check if we can shrink the allocated area    if (new_blocks < n_blocks) {        // free unneeded tail blocks        for (size_t bl = block + new_blocks, count = n_blocks - new_blocks; count > 0; bl++, count--) {            ATB_ANY_TO_FREE(bl);        }        // set the last_free pointer to end of this block if it's earlier in the heap        if ((block + new_blocks) / BLOCKS_PER_ATB < MP_STATE_MEM(gc_last_free_atb_index)) {            MP_STATE_MEM(gc_last_free_atb_index) = (block + new_blocks) / BLOCKS_PER_ATB;        }        #if EXTENSIVE_HEAP_PROFILING        gc_dump_alloc_table();        #endif        return ptr_in;    }    // check if we can expand in place    if (new_blocks <= n_blocks + n_free) {        // mark few more blocks as used tail        for (size_t bl = block + n_blocks; bl < block + new_blocks; bl++) {            assert(ATB_GET_KIND(bl) == AT_FREE);            ATB_FREE_TO_TAIL(bl);        }        // zero out the bytes of the newly allocated blocks (see comment above in gc_alloc)        memset((byte*)ptr_in + n_blocks * BYTES_PER_BLOCK, 0, (new_blocks - n_blocks) * BYTES_PER_BLOCK);        #if EXTENSIVE_HEAP_PROFILING        gc_dump_alloc_table();        #endif        return ptr_in;//.........这里部分代码省略.........