page compaction代码分析之一

/*
 * Determines how hard direct compaction should try to succeed.
 * Lower value means higher priority, analogically to reclaim priority.
 */
enum compact_priority {
    COMPACT_PRIO_SYNC_FULL,
    MIN_COMPACT_PRIORITY = COMPACT_PRIO_SYNC_FULL,
    COMPACT_PRIO_SYNC_LIGHT,
    MIN_COMPACT_COSTLY_PRIORITY = COMPACT_PRIO_SYNC_LIGHT,
    DEF_COMPACT_PRIORITY = COMPACT_PRIO_SYNC_LIGHT,
    COMPACT_PRIO_ASYNC,
    INIT_COMPACT_PRIORITY = COMPACT_PRIO_ASYNC
};

/* Return values for compact_zone() and try_to_compact_pages() */
/* When adding new states, please adjust include/trace/events/compaction.h */
enum compact_result {
    /* For more detailed tracepoint output - internal to compaction */
    COMPACT_NOT_SUITABLE_ZONE,
    /*
     * compaction didn't start as it was not possible or direct reclaim
     * was more suitable
     */
    COMPACT_SKIPPED,
    /* compaction didn't start as it was deferred due to past failures */
    COMPACT_DEFERRED,
 
    /* compaction not active last round */
    COMPACT_INACTIVE = COMPACT_DEFERRED,
 
    /* For more detailed tracepoint output - internal to compaction */
    COMPACT_NO_SUITABLE_PAGE,
    /* compaction should continue to another pageblock */
    COMPACT_CONTINUE,
 
    /*
     * The full zone was compacted scanned but wasn't successfull to compact
     * suitable pages.
     */
    COMPACT_COMPLETE,
    /*
     * direct compaction has scanned part of the zone but wasn't successfull
     * to compact suitable pages.
     */
    COMPACT_PARTIAL_SKIPPED,
 
    /* compaction terminated prematurely due to lock contentions */
    COMPACT_CONTENDED,
 
    /*
     * direct compaction terminated after concluding that the allocation
     * should now succeed
     */
    COMPACT_SUCCESS,
};

root:/ # cat /proc/sys/vm/extfrag_threshold
500

enum compact_result compaction_suitable(struct zone *zone, int order,
                    unsigned int alloc_flags,
                    int classzone_idx)
{
    enum compact_result ret;
    int fragindex;
 
    ret = __compaction_suitable(zone, order, alloc_flags, classzone_idx,
                    zone_page_state(zone, NR_FREE_PAGES));
    /*
     * fragmentation index determines if allocation failures are due to
     * low memory or external fragmentation
     *
     * index of -1000 would imply allocations might succeed depending on
     * watermarks, but we already failed the high-order watermark check
     * index towards 0 implies failure is due to lack of memory
     * index towards 1000 implies failure is due to fragmentation
     *
     * Only compact if a failure would be due to fragmentation. Also
     * ignore fragindex for non-costly orders where the alternative to
     * a successful reclaim/compaction is OOM. Fragindex and the
     * vm.extfrag_threshold sysctl is meant as a heuristic to prevent
     * excessive compaction for costly orders, but it should not be at the
     * expense of system stability.
     */
    if (ret == COMPACT_CONTINUE && (order > PAGE_ALLOC_COSTLY_ORDER)) {
        fragindex = fragmentation_index(zone, order);
        if (fragindex >= 0 && fragindex <= sysctl_extfrag_threshold)
            ret = COMPACT_NOT_SUITABLE_ZONE;
    }
 
    trace_mm_compaction_suitable(zone, order, ret);
    if (ret == COMPACT_NOT_SUITABLE_ZONE)
        ret = COMPACT_SKIPPED;
 
    return ret;
}

static enum compact_result __compaction_suitable(struct zone *zone, int order,
                    unsigned int alloc_flags,
                    int classzone_idx,
                    unsigned long wmark_target)
{
    unsigned long watermark;
 
    if (is_via_compact_memory(order))
        return COMPACT_CONTINUE;
 
    watermark = wmark_pages(zone, alloc_flags & ALLOC_WMARK_MASK);
    /*
     * If watermarks for high-order allocation are already met, there
     * should be no need for compaction at all.
     */
    if (zone_watermark_ok(zone, order, watermark, classzone_idx,
                                alloc_flags))
        return COMPACT_SUCCESS;
 
    watermark = (order > PAGE_ALLOC_COSTLY_ORDER) ?
                low_wmark_pages(zone) : min_wmark_pages(zone);
    watermark += compact_gap(order);
    if (!__zone_watermark_ok(zone, 0, watermark, classzone_idx,
                        ALLOC_CMA, wmark_target))
        return COMPACT_SKIPPED;
 
    return COMPACT_CONTINUE;
}

struct zone {
#ifdef CONFIG_COMPACTION
    /*
     * On compaction failure, 1<<compact_defer_shift compactions
     * are skipped before trying again. The number attempted since
     * last failure is tracked with compact_considered.
     */
    unsigned int        compact_considered;
    unsigned int        compact_defer_shift;
    int         compact_order_failed;
#endif
}

/* Do not skip compaction more than 64 times */
#define COMPACT_MAX_DEFER_SHIFT 6
 
 
void defer_compaction(struct zone *zone, int order)
{
    zone->compact_considered = 0;
    zone->compact_defer_shift++;
 
    if (order < zone->compact_order_failed)
        zone->compact_order_failed = order;
 
    if (zone->compact_defer_shift > COMPACT_MAX_DEFER_SHIFT)
        zone->compact_defer_shift = COMPACT_MAX_DEFER_SHIFT;
}

void compaction_defer_reset(struct zone *zone, int order, bool alloc_success)
{
    if (alloc_success) {
        zone->compact_considered = 0;
        zone->compact_defer_shift = 0;
    }
    if (order >= zone->compact_order_failed)
        zone->compact_order_failed = order + 1;
}

static enum compact_result __compact_finished(struct compact_control *cc)
{
        if (compact_scanners_met(cc)) {                          //相遇了
        /* Let the next compaction start anew. */
        reset_cached_positions(cc->zone);
 
        /*
         * Mark that the PG_migrate_skip information should be cleared
         * by kswapd when it goes to sleep. kcompactd does not set the
         * flag itself as the decision to be clear should be directly
         * based on an allocation request.
         */
        if (cc->direct_compaction)
            cc->zone->compact_blockskip_flush = true;
 
        if (cc->whole_zone)
            return COMPACT_COMPLETE;
        else
            return COMPACT_PARTIAL_SKIPPED;
    }
 
 
    for (order = cc->order; order < MAX_ORDER; order++) {
        struct free_area *area = &cc->zone->free_area[order];
        bool can_steal;
 
        /* Job done if page is free of the right migratetype */          //有空闲内存了，返回SUCCESS
        if (!list_empty(&area->free_list[migratetype]))
            return COMPACT_SUCCESS;
 
#ifdef CONFIG_CMA
        /* MIGRATE_MOVABLE can fallback on MIGRATE_CMA */
        if (migratetype == MIGRATE_MOVABLE &&
            !list_empty(&area->free_list[MIGRATE_CMA]))
            return COMPACT_SUCCESS;
#endif
 
 
 
 
        if (find_suitable_fallback(area, order, migratetype,            //从备用迁移类型中分配成功了。
                        true, &can_steal, cc->order) != -1) {
 
            /* movable pages are OK in any pageblock */
            if (migratetype == MIGRATE_MOVABLE)
                return COMPACT_SUCCESS;
}