Redis 内存碎片整理调研

#define INTERPOLATE(x, x1, x2, y1, y2) ( (y1) + ((x)-(x1)) * ((y2)-(y1)) / ((x2)-(x1)) )
#define LIMIT(y, min, max) ((y)<(min)? min: ((y)>(max)? max: (y)))
 
/* decide if defrag is needed, and at what CPU effort to invest in it */
void computeDefragCycles() {
    size_t frag_bytes;
    // 获得内存碎片率和内存碎片的总字节数
    float frag_pct = getAllocatorFragmentation(&frag_bytes);
    /* If we're not already running, and below the threshold, exit. */
    // 如果当前未进行内存碎片整理，且内存碎片率和内存碎片总字节数不满足阈值要求，退出
    if (!server.active_defrag_running) {
        if(frag_pct < server.active_defrag_threshold_lower || frag_bytes < server.active_defrag_ignore_bytes)
            return;
    }
 
    /* Calculate the adaptive aggressiveness of the defrag */
    // 自适应计算内存碎片清理的 cpu 占用百分比
    int cpu_pct = INTERPOLATE(frag_pct,
            server.active_defrag_threshold_lower,
            server.active_defrag_threshold_upper,
            server.active_defrag_cycle_min,
            server.active_defrag_cycle_max);
    // 将 cpu 占用百分比限制在 [active_defrag_cycle_min, active_defrag_cycle_max]
    cpu_pct = LIMIT(cpu_pct,
            server.active_defrag_cycle_min,
            server.active_defrag_cycle_max);
     /* We allow increasing the aggressiveness during a scan, but don't
      * reduce it. */
    if (cpu_pct > server.active_defrag_running) {
        // 记录比率
        server.active_defrag_running = cpu_pct;
        serverLog(LL_VERBOSE,
            "Starting active defrag, frag=%.0f%%, frag_bytes=%zu, cpu=%d%%",
            frag_pct, frag_bytes, cpu_pct);
    }
}

/* Defrag helper for generic allocations.
 *
 * returns NULL in case the allocation wasn't moved.
 * when it returns a non-null value, the old pointer was already released
 * and should NOT be accessed. */
void* activeDefragAlloc(void *ptr) {
    size_t size;
    void *newptr;
    if(!je_get_defrag_hint(ptr)) {
        server.stat_active_defrag_misses++;
        return NULL;
    }
    /* move this allocation to a new allocation.
     * make sure not to use the thread cache. so that we don't get back the same
     * pointers we try to free */
    size = zmalloc_size(ptr);
    // 分配新内存
    newptr = zmalloc_no_tcache(size);
    // 内存复制
    memcpy(newptr, ptr, size);
    // 释放旧内存
    zfree_no_tcache(ptr);
    return newptr;
}

do {
    int quit = 0;
    if (defragLaterItem(de, &defrag_later_cursor, endtime,db->id))
        quit = 1; /* time is up, we didn't finish all the work */
 
    /* Once in 16 scan iterations, 512 pointer reallocations, or 64 fields
        * (if we have a lot of pointers in one hash bucket, or rehashing),
        * check if we reached the time limit. */
    if (quit || (++iterations > 16 ||
                    server.stat_active_defrag_hits - prev_defragged > 512 ||
                    server.stat_active_defrag_scanned - prev_scanned > 64)) {
        if (quit || ustime() > endtime) {
            if(key_defragged != server.stat_active_defrag_hits)
                server.stat_active_defrag_key_hits++;
            else
                server.stat_active_defrag_key_misses++;
            return 1;
        }
        iterations = 0;
        prev_defragged = server.stat_active_defrag_hits;
        prev_scanned = server.stat_active_defrag_scanned;
    }
} while(defrag_later_cursor);