1、负载均衡流程图

2、触发负载均衡函数trigger_load_balance

void trigger_load_balance(struct rq *rq)
{
    /* Don't need to rebalance while attached to NULL domain */
    if (unlikely(on_null_domain(rq)))//当前调度队列中的调度域是空的则返回
        return;

    if (time_after_eq(jiffies, rq->next_balance))//判断下一次均衡的时间是否到
        raise_softirq(SCHED_SOFTIRQ);//触发软中断，在init_sched_fair_class中初始化open_softirq(SCHED_SOFTIRQ, run_rebalance_domains);
#ifdef CONFIG_NO_HZ_COMMON
    if (nohz_kick_needed(rq, false))
        nohz_balancer_kick(false);
#endif
}

2.1 run_rebalance_domains

static __latent_entropy void run_rebalance_domains(struct softirq_action *h)
{
    struct rq *this_rq = this_rq();//获取当前运行队列
    enum cpu_idle_type idle = this_rq->idle_balance ?
                        CPU_IDLE : CPU_NOT_IDLE;//判断当前运行队列是空闲还是非空闲

    /*
     * If this cpu has a pending nohz_balance_kick, then do the
     * balancing on behalf of the other idle cpus whose ticks are
     * stopped. Do nohz_idle_balance *before* rebalance_domains to
     * give the idle cpus a chance to load balance. Else we may
     * load balance only within the local sched_domain hierarchy
     * and abort nohz_idle_balance altogether if we pull some load.
     */
    nohz_idle_balance(this_rq, idle);//给空闲cpu一个均衡的机会进行均衡，
    update_blocked_averages(this_rq->cpu);//更新阻塞平均值
#ifdef CONFIG_NO_HZ_COMMON
    if (!test_bit(NOHZ_STATS_KICK, nohz_flags(this_rq->cpu)))//如果当前cpu设置了NOHZ_STATS_KICK,则跳过，否则进行rebalance_domain
        rebalance_domains(this_rq, idle);
    clear_bit(NOHZ_STATS_KICK, nohz_flags(this_rq->cpu));
#else
    rebalance_domains(this_rq, idle);
#endif
}

2.1.1 nohz_idle_balance

static void nohz_idle_balance(struct rq *this_rq, enum cpu_idle_type idle)
{
    int this_cpu = this_rq->cpu;//获取cpu
    struct rq *rq;
    struct sched_domain *sd;
    int balance_cpu;
    /* Earliest time when we have to do rebalance again */
    unsigned long next_balance = jiffies + 60*HZ;
    int update_next_balance = 0;
#ifdef CONFIG_SPRD_CORE_CTL
    cpumask_t cpus;
#endif

    if (idle != CPU_IDLE ||
        !test_bit(NOHZ_BALANCE_KICK, nohz_flags(this_cpu)))//如果cpu不是空闲，或者设置了NOHZ_BALANCE_KICK，则返回
        goto end;

    /*
     * This cpu is going to update the blocked load of idle CPUs either
     * before doing a rebalancing or just to keep metrics up to date. we
     * can safely update the next update timestamp
     */
    rcu_read_lock();//rcu读锁
    sd = rcu_dereference(this_rq->sd);//获取当前this_rq的调度域
    /*
     * Check whether there is a sched_domain available for this cpu.
     * The last other cpu can have been unplugged since the ILB has been
     * triggered and the sched_domain can now be null. The idle balance
     * sequence will quickly be aborted as there is no more idle CPUs
     */
    if (sd)
        nohz.next_update = jiffies + msecs_to_jiffies(LOAD_AVG_PERIOD);//计算下一次空闲cpu负载均衡的时间
    rcu_read_unlock();

    cpumask_andnot(&cpus, nohz.idle_cpus_mask, cpu_isolated_mask);移除隔离的cpu
    for_each_cpu(balance_cpu, &cpus) {//遍历空闲cpu

        if (balance_cpu == this_cpu || !idle_cpu(balance_cpu))//如果均衡cpu是当前cpu或者不是空闲的，则进行下一个循环。
            continue;

        /*
         * If this cpu gets work to do, stop the load balancing
         * work being done for other cpus. Next load
         * balancing owner will pick it up.
         */
        if (need_resched())//判断如果此cpu需要调度，则停止均衡
            break;

        rq = cpu_rq(balance_cpu);//获取要均衡cpu的运行队列

        /*
         * If time for next balance is due,
         * do the balance.
         */
        if (time_after_eq(jiffies, rq->next_balance)) {//判断均衡时间有没有到
            struct rq_flags rf;

            rq_lock_irq(rq, &rf);//获取运行队列锁
            update_rq_clock(rq);//更新运行队列时钟
            cpu_load_update_idle(rq);//更新队列负载
            rq_unlock_irq(rq, &rf);//释放锁

            update_blocked_averages(balance_cpu);//更新均衡cpu的阻塞平均值
            /*
             * This idle load balance softirq may have been
             * triggered only to update the blocked load and shares
             * of idle CPUs (which we have just done for
             * balance_cpu). In that case skip the actual balance.
             */
            if (!test_bit(NOHZ_STATS_KICK, nohz_flags(this_cpu)))//如果没有设置NOHZ_STATS_KICK，则进行均衡
                rebalance_domains(rq, idle);//域负载均衡
        }

        if (time_after(next_balance, rq->next_balance)) {//更新下一次均衡时间
            next_balance = rq->next_balance;
            update_next_balance = 1;
        }
    }

    /*
     * next_balance will be updated only when there is a need.
     * When the CPU is attached to null domain for ex, it will not be
     * updated.
     */
    if (likely(update_next_balance))//更新下一次均衡时间
        nohz.next_balance = next_balance;
end:
    clear_bit(NOHZ_BALANCE_KICK, nohz_flags(this_cpu));
}

2.2 rebalance_domains函数

static void rebalance_domains(struct rq *rq, enum cpu_idle_type idle)
{
    int continue_balancing = 1;
    int cpu = rq->cpu;
    unsigned long interval;
    struct sched_domain *sd;
    /* Earliest time when we have to do rebalance again */
    unsigned long next_balance = jiffies + 60*HZ;
    int update_next_balance = 0;
    int need_serialize, need_decay = 0;
    u64 max_cost = 0;

    rcu_read_lock();

    for_each_domain(cpu, sd) {//遍历调度域中每个cpu
        /*
         * Decay the newidle max times here because this is a regular
         * visit to all the domains. Decay ~1% per second.
         */
        if (time_after(jiffies, sd->next_decay_max_lb_cost)) {//判断衰减时间有没有到
            sd->max_newidle_lb_cost =
                (sd->max_newidle_lb_cost * 253) / 256;//衰减百分之一
            sd->next_decay_max_lb_cost = jiffies + HZ;//衰减时间更新
            need_decay = 1;
        }
        max_cost += sd->max_newidle_lb_cost;

        if (energy_aware() && !sd_overutilized(sd) && !sd->parent)//在使能了eas且调度域没有过载已及这是个根调度域时跳过
            continue;

        if (!(sd->flags & SD_LOAD_BALANCE)) {//判断此调度域是否设置了SD_LOAD_BALANCE
            if (time_after_eq(jiffies,
                      sd->groups->sgc->next_update))
                update_group_capacity(sd, cpu);//更新cpu调度组能力
            continue;
        }

        /*
         * Stop the load balance at this level. There is another
         * CPU in our sched group which is doing load balancing more
         * actively.
         */
        if (!continue_balancing) {//判断是否停止均衡
            if (need_decay)
                continue;
            break;
        }

        interval = get_sd_balance_interval(sd, idle != CPU_IDLE);//得到调度域的均衡间隔

        need_serialize = sd->flags & SD_SERIALIZE;//判断是否需要串行化
        if (need_serialize) {
            if (!spin_trylock(&balancing))//获取锁
                goto out;
        }

        if (time_after_eq(jiffies, sd->last_balance + interval)) {//判断均衡时间是否到
            if (load_balance(cpu, rq, sd, idle, &continue_balancing)) {//进行均衡
                /*
                 * The LBF_DST_PINNED logic could have changed
                 * env->dst_cpu, so we can't know our idle
                 * state even if we migrated tasks. Update it.
                 */
                idle = idle_cpu(cpu) ? CPU_IDLE : CPU_NOT_IDLE;//获取cpu空闲状态
            }
            sd->last_balance = jiffies;//更新均衡时间
            interval = get_sd_balance_interval(sd, idle != CPU_IDLE);//获取均衡间隔
        }
        if (need_serialize)
            spin_unlock(&balancing);//释放锁
out:
        if (time_after(next_balance, sd->last_balance + interval)) {//判断next_balance是否需要更新
            next_balance = sd->last_balance + interval;
            update_next_balance = 1;
        }
    }
    if (need_decay) {//判断是否需要衰减
        /*
         * Ensure the rq-wide value also decays but keep it at a
         * reasonable floor to avoid funnies with rq->avg_idle.
         */
        rq->max_idle_balance_cost =
            max((u64)sysctl_sched_migration_cost, max_cost);
    }
    rcu_read_unlock();

    /*
     * next_balance will be updated only when there is a need.
     * When the cpu is attached to null domain for ex, it will not be
     * updated.
     */
    if (likely(update_next_balance)) {
        rq->next_balance = next_balance;//更新运行队列下一次均衡时间

#ifdef CONFIG_NO_HZ_COMMON
        /*
         * If this CPU has been elected to perform the nohz idle
         * balance. Other idle CPUs have already rebalanced with
         * nohz_idle_balance() and nohz.next_balance has been
         * updated accordingly. This CPU is now running the idle load
         * balance for itself and we need to update the
         * nohz.next_balance accordingly.
         */
        if ((idle == CPU_IDLE) && time_after(nohz.next_balance, rq->next_balance))//如果cpu状态是空闲且运行队列的下次均衡时间小于空闲cpu的下次均衡时间
            nohz.next_balance = rq->next_balance;//更新空闲cpu的下次均衡时间
#endif
    }
}

2.2.1 load_balance

static int load_balance(int this_cpu, struct rq *this_rq,
            struct sched_domain *sd, enum cpu_idle_type idle,
            int *continue_balancing)
{
    int ld_moved, cur_ld_moved, active_balance = 0;
    struct sched_domain *sd_parent = lb_sd_parent(sd) ? sd->parent : NULL;
    struct sched_group *group;
    struct rq *busiest;
    struct rq_flags rf;
    struct cpumask *cpus = this_cpu_cpumask_var_ptr(load_balance_mask);

    

struct lb_env env = {//负载平衡环境，包含了一组与负载平衡相关的参数和状态信息
        .sd        = sd,//调度域
        .dst_cpu    = this_cpu,//均衡给此cpu
        .dst_rq        = this_rq,//均衡给此队列
        .dst_grpmask    = sched_group_span(sd->groups),//目标调度组掩码
        .idle        = idle,//cpu状态
        .loop_break    = sched_nr_migrate_break,//迁移间隔
        .cpus        = cpus,
        .fbq_type    = all,
        .tasks        = LIST_HEAD_INIT(env.tasks),
    };

    cpumask_and(cpus, sched_domain_span(sd), cpu_active_mask);//将调度域中处于active状态的cpu挑选出来

    schedstat_inc(sd->lb_count[idle]);//更新负载均衡idle类型的计数

redo:
    if (!should_we_balance(&env)) {//判断是否应该均衡
        *continue_balancing = 0;
        goto out_balanced;
    }

    group = find_busiest_group(&env);//找到最繁忙的组
    if (!group) {
        schedstat_inc(sd->lb_nobusyg[idle]);
        goto out_balanced;
    }

    busiest = find_busiest_queue(&env, group);//找到最繁忙的队列
    if (!busiest) {
        schedstat_inc(sd->lb_nobusyq[idle]);
        goto out_balanced;
    }

    BUG_ON(busiest == env.dst_rq);//最繁忙的队列不等于目的队列

    schedstat_add(sd->lb_imbalance[idle], env.imbalance);更新负载均衡idle类型不均衡的计数

    env.src_cpu = busiest->cpu;//最繁忙的队列的cpu给要均衡的cpu
    env.src_rq = busiest;//最繁忙的队列给要均衡的队列

    ld_moved = 0;
    if (busiest->nr_running > 1) {最繁忙的运行队列中的task要大于1
        /*
         * Attempt to move tasks. If find_busiest_group has found
         * an imbalance but busiest->nr_running <= 1, the group is
         * still unbalanced. ld_moved simply stays zero, so it is
         * correctly treated as an imbalance.
         */
        env.flags |= LBF_ALL_PINNED;
        env.loop_max  = min(sysctl_sched_nr_migrate, busiest->nr_running);//最大循环的次数

more_balance:
        rq_lock_irqsave(busiest, &rf);//获取锁
        update_rq_clock(busiest);//更新最忙的队列的时钟

        /*
         * cur_ld_moved - load moved in current iteration
         * ld_moved     - cumulative load moved across iterations
         */
        cur_ld_moved = detach_tasks(&env, &rf);//出队，将要迁移的task从src cpu中移除并返回出队的个数

        /*
         * We've detached some tasks from busiest_rq. Every
         * task is masked "TASK_ON_RQ_MIGRATING", so we can safely
         * unlock busiest->lock, and we are able to be sure
         * that nobody can manipulate the tasks in parallel.
         * See task_rq_lock() family for the details.
         */

        rq_unlock(busiest, &rf);//释放锁

        if (cur_ld_moved) {
            attach_tasks(&env);//入队，将移除的task加入到新的队列中
            ld_moved += cur_ld_moved;
        }

        local_irq_restore(rf.flags);//恢复本地的中断状态

        if (env.flags & LBF_NEED_BREAK) {//判断是否设置了LBF_NEED_BREAK
            env.flags &= ~LBF_NEED_BREAK;
            goto more_balance;
        }

        /*
         * Revisit (affine) tasks on src_cpu that couldn't be moved to
         * us and move them to an alternate dst_cpu in our sched_group
         * where they can run. The upper limit on how many times we
         * iterate on same src_cpu is dependent on number of cpus in our
         * sched_group.
         *
         * This changes load balance semantics a bit on who can move
         * load to a given_cpu. In addition to the given_cpu itself
         * (or a ilb_cpu acting on its behalf where given_cpu is
         * nohz-idle), we now have balance_cpu in a position to move
         * load to given_cpu. In rare situations, this may cause
         * conflicts (balance_cpu and given_cpu/ilb_cpu deciding
         * _independently_ and at _same_ time to move some load to
         * given_cpu) causing exceess load to be moved to given_cpu.
         * This however should not happen so much in practice and
         * moreover subsequent load balance cycles should correct the
         * excess load moved.
         */
        if ((env.flags & LBF_DST_PINNED) && env.imbalance > 0) {//如果sched domain仍然未达均衡均衡状态，并且在之前的均衡过程中，有因为affinity的原因导致任务无法迁移到dest cpu，这时候要继续在src rq上搜索任务，迁移到备选的dest cpu，因此，这里再次发起均衡操作。这里的均衡上下文的dest cpu设定为备选的cpu，loop也被清零，重新开始扫描。

            /* Prevent to re-select dst_cpu via env's cpus */
            cpumask_clear_cpu(env.dst_cpu, env.cpus);

            env.dst_rq     = cpu_rq(env.new_dst_cpu);//备用cpu队列
            env.dst_cpu     = env.new_dst_cpu;
            env.flags    &= ~LBF_DST_PINNED;
            env.loop     = 0;
            env.loop_break     = sched_nr_migrate_break;

            /*
             * Go back to "more_balance" rather than "redo" since we
             * need to continue with same src_cpu.
             */
            goto more_balance;
        }

        /*
         * We failed to reach balance because of affinity.
         */
        if (sd_parent) {//如果父调度域存在
            int *group_imbalance = &sd_parent->groups->sgc->imbalance;

            if ((env.flags & LBF_SOME_PINNED) && env.imbalance > 0)//由于亲和性原因不能在目标cpu上迁移而设置了LBF_SOME_PINNED
                *group_imbalance = 1;
        }

        /* All tasks on this runqueue were pinned by CPU affinity */
        if (unlikely(env.flags & LBF_ALL_PINNED)) {//设置了LBF_ALL_PINNED，由于亲和性原因在这个运行队列上的所有的任务不能迁移
            cpumask_clear_cpu(cpu_of(busiest), cpus);//清除在cpus中的busiest所在的cpu
            /*
             * Attempting to continue load balancing at the current
             * sched_domain level only makes sense if there are
             * active CPUs remaining as possible busiest CPUs to
             * pull load from which are not contained within the
             * destination group that is receiving any migrated
             * load.
             */
            if (!cpumask_subset(cpus, env.dst_grpmask)) {//如果选中的busiest cpu上的任务全部都是通过affinity锁定在了该cpu上，那么清除该cpu（为了确保下轮均衡不考虑该cpu），再次发起均衡。这种情况下，需要重新搜索source cpu，因此跳转到redo
                env.loop = 0;
                env.loop_break = sched_nr_migrate_break;
                goto redo;
            }
            goto out_all_pinned;
        }
    }

    if (!ld_moved) {//如果前面迁移的task如果为0，则走这里
        schedstat_inc(sd->lb_failed[idle]);//增加负载均衡lb_failed计数
        /*
         * Increment the failure counter only on periodic balance.
         * We do not want newidle balance, which can be very
         * frequent, pollute the failure counter causing
         * excessive cache_hot migrations and active balances.
         */
        if (idle != CPU_NEWLY_IDLE)//如果cpu状态不是刚刚处于空闲状态
            if (env.src_grp_nr_running > 1)//要迁移的调度组中的队列个数大于1
                sd->nr_balance_failed++;//失败计数加一

        if (need_active_balance(&env)) {//判断是否要启动active balance。所谓activebalance就是把当前正在运行的任务迁移到dest cpu上。也就是说经过前面一番折腾，runnable的任务都无法迁移到dest cpu，从而达到均衡，那么就考虑当前正在运行的任务
            unsigned long flags;

            raw_spin_lock_irqsave(&busiest->lock, flags);

            /* don't kick the active_load_balance_cpu_stop,
             * if the curr task on busiest cpu can't be
             * moved to this_cpu
             */
            if (!cpumask_test_cpu(this_cpu, &busiest->curr->cpus_allowed)) {//在启动active balance之前，先看看busiestcpu上当前正在运行的任务是否可以运行在dest cpu上。如果不可以的话，那么不再试图执行均衡操作，跳转到out_one_pinned
                raw_spin_unlock_irqrestore(&busiest->lock,
                                flags);
                env.flags |= LBF_ALL_PINNED;
                goto out_one_pinned;
            }

            /*
             * ->active_balance synchronizes accesses to
             * ->active_balance_work.  Once set, it's cleared
             * only after active load balance is finished.
             */
#ifdef CONFIG_SPRD_CORE_CTL
            if (!busiest->active_balance &&
                !cpu_isolated(cpu_of(busiest))) {
#else
            if (!busiest->active_balance) {//busiest cpu运行队列上设置active balance的标记
#endif
                busiest->active_balance = 1;
                busiest->push_cpu = this_cpu;
                active_balance = 1;
            }
            raw_spin_unlock_irqrestore(&busiest->lock, flags);

            if (active_balance) {//将正在运行的busiest cpu 正在运行的任务停止并进行迁移
                stop_one_cpu_nowait(cpu_of(busiest),
                    active_load_balance_cpu_stop, busiest,
                    &busiest->active_balance_work);
            }

            /* We've kicked active balancing, force task migration. */
            sd->nr_balance_failed = sd->cache_nice_tries+1;
        }
    } else
        sd->nr_balance_failed = 0;//完成了至少一个任务迁移

    if (likely(!active_balance)) {
        /* We were unbalanced, so reset the balancing interval */
        sd->balance_interval = sd->min_interval;//重新设置均衡间隔
    } else {
        /*
         * If we've begun active balancing, start to back off. This
         * case may not be covered by the all_pinned logic if there
         * is only 1 task on the busy runqueue (because we don't call
         * detach_tasks).
         */
        if (sd->balance_interval < sd->max_interval)
            sd->balance_interval *= 2;
    }

    goto out;

out_balanced:
    /*
     * We reach balance although we may have faced some affinity
     * constraints. Clear the imbalance flag if it was set.
     */
    if (sd_parent) {
        int *group_imbalance = &sd_parent->groups->sgc->imbalance;

        if (*group_imbalance)
            *group_imbalance = 0;
    }

out_all_pinned://由于所有的亲和性原因
    /*
     * We reach balance because all tasks are pinned at this level so
     * we can't migrate them. Let the imbalance flag set so parent level
     * can try to migrate them.
     */
    schedstat_inc(sd->lb_balanced[idle]);

    sd->nr_balance_failed = 0;

out_one_pinned://由某个task亲和性原因
    ld_moved = 0;

    /*
     * idle_balance() disregards balance intervals, so we could repeatedly
     * reach this code, which would lead to balance_interval skyrocketting
     * in a short amount of time. Skip the balance_interval increase logic
     * to avoid that.
     */
    if (env.idle == CPU_NEWLY_IDLE)
        goto out;

    /* tune up the balancing interval */
    if (((env.flags & LBF_ALL_PINNED) &&
            sd->balance_interval < MAX_PINNED_INTERVAL) ||
            (sd->balance_interval < sd->max_interval))
        sd->balance_interval *= 2;
out:
    return ld_moved;
}