Linux组调度

为什么引入组调度可以参考这篇文章的讨论。核心原因是基础的调度算法都是基于任务的，如果用户A有10个任务，用户B只有1个任务，假设这些任务的优先级都相同，那么用户A得到的CPU时间将是用户B的10倍，这样从任务的角度看虽然是公平的，但是从用户角度看这不一定合理。引入组调度后，可以将用户A的任务安排为GroupA，用户B的任务安排为GroupB，调度算法在GroupA和GroupB之间平均分配CPU时间即可，由此可以解决上面提到的问题。

组调度是一个可选的特性，基础开关为CONFIG_SCHED_GROUP，开启该开关后，将基于CGROUP机制实现一个名为cpu的资源控制器，该控制器实现对CPU时间的管理。目前只有RT调度器和CFS调度器支持组调度，它们的开关分别为CONFIG_RT_GROUP_SCHED和CONFIG_FAIR_GROUP_SCHED，要实现完整的组调度功能，这两个宏至少要打开一个。

为了减小理解组调度的难度，这篇笔记以RT组调度为例分析组调度相关的实现，CFS组调度的实现在单独的笔记中总结。

关键数据结构

任务组: task_group

组调度引入了task_group表示任务组，task_group和cgroup分组对应，每个cgroup分组都会存在一个对应的task_group实例。

struct task_group {
    struct cgroup_subsys_state css; // ---(1)

#ifdef CONFIG_FAIR_GROUP_SCHED // ---(2)
    /* schedulable entities of this group on each cpu */
    struct sched_entity **se;
    /* runqueue "owned" by this group on each cpu */
    struct cfs_rq **cfs_rq;
    unsigned long shares;
#endif
#ifdef CONFIG_RT_GROUP_SCHED
    struct sched_rt_entity **rt_se;
    struct rt_rq **rt_rq;

    struct rt_bandwidth rt_bandwidth;
#endif

    struct rcu_head rcu; // ---(3)
    struct list_head list;
    struct task_group *parent;
    struct list_head siblings;
    struct list_head children;

    struct cfs_bandwidth cfs_bandwidth;
};
  1. CGROUP相关字段。
  2. 分别对应RT任务组调度和CFS任务组调度的字段。核心字段是rq数组和se数组，每个CPU对应一个调度实体和一个运行队列。见下面“任务的组织”部分介绍
  3. 用来组织系统中所有的task_group实例，见下面“任务组的管理”部分介绍。

任务组的管理

系统用一个链表+一棵树来管理所有的task_group实例：

  1. 用list字段将所有task_group实例组织为一个链表，表头为task_groups。
LIST_HEAD(task_groups);
  1. 属于同一层的task_group实例用siblings字段组织成链表，链表头为上一层task_group实例中的children字段。下一层task_group实例的parent字段指向上一层的task_group实例。系统定义了一个根任务组root_task_group实例，根分组也是默认的任务分组。
/*
 * Default task group.
 * Every task in system belongs to this group at bootup.
 */
struct task_group root_task_group;

下图表示在根分组下有两个一级分组的数据结构示意图：

  • 红色线条表示所有的分组形成单链表；绿色的线条表示相邻两个层级之间的task_group实例是如何组织的。
  • 根分组没有parent，其它分组的parent指向其上一层级的task_group实例。

任务的组织

每个task_group实例对应一个分组，一个分组进一步由若干个任务和子分组组织，如此嵌套，则系统中所有的任务都分散组织在了task_group树中。我们知道调度单位是任务，所以每个task_group实例需要能够合理的管理属于自己的任务和子分组。

首先，task_group针对每个CPU都有一个运行队列，该运行队列管理了所有属于该分组并且调度到该CPU上的任务。

其次，支持组调度后，调度实体的概念进行了扩展，它不仅仅可以代表一个任务，也可以代表一个任务组。task_group针对每个CPU都分配一个调度实体，这样，每当该分组有任务分配到某个CPU上时，就可以将对应CPU的调度实体挂到该任务组的父亲的对应CPU运行队列中。

假设一个系统有任务TaskA、TaskB以及任务组GroupA、GroupB，其中GroupA为根分组，GroupA包含GroupB分组以及TaskA，TaskB属于GroupB。下图为相关数据结构（以RT任务为例）示意图。

  1. GroupA为根任务组，它包含了GroupB和TaskA，所以TaskA的调度实体和GroupB的调度实体会被组织到GroupA的运行队列中。特别的，GroupA为根分组，其运行队列就是CPU的运行队列。
  2. 由于GroupA为根分组，所以其不需要调度实体，因为调度器总是会从它的运行队列开始寻找要运行的任务。
  3. GoupB作为一个普通分组，它有自己的调度实体，通过该调度实体才能将GroupB组织到GroupA的运行队列中。
  4. GroupB只包含了TaskB，所以它的运行队列中只有TaskB的调度实体。

运行队列&调度实体

运行队列（以RT运行队列为例）中增加了如下和组调度相关的字段：

  1. 保存了运行队列中最高优先级的调度实体，其作用后面介绍。
  2. rq指向CPU的运行队列。tg指向运行队列所属任务组，特别的，CPU运行队列中的该字段指向根任务组。
struct rt_rq {
    struct rt_prio_array active;
...
#if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
struct {
    int curr; /* highest queued rt task prio */

} highest_prio; // ---(1)
#endif

#ifdef CONFIG_RT_GROUP_SCHED
    unsigned long rt_nr_boosted;

    struct rq *rq; // ---(2)
    struct task_group *tg;
#endif
};

调度实体（以RT调度实体为例）中增加了如下和组调度相关的字段：

  1. 如果调度实体代表一个任务，rt_rq指向所属任务组的运行队列；parent指向所属任务组的调度实体；my_q为NULL。如果它代表一个任务组，rt_rq指向上一层任务组的运行队列；parent指向上一层任务组的调度实体；my_q指向该任务组自己的运行队列，即用来管理属于自己这个任务组的调度实体的运行队列。
struct sched_rt_entity {
    struct list_head run_list;
    struct sched_rt_entity *back; // 作用见下面RT任务组优先级部分介绍
...
#ifdef CONFIG_RT_GROUP_SCHED
    struct sched_rt_entity    *parent; // ---(1)
    /* rq on which this entity is (to be) queued: */
    struct rt_rq *rt_rq;
    /* rq "owned" by this entity/group: */
    struct rt_rq *my_q;
#endif
};

开机初始化

开机时，在sched_init()中会对根任务组实例进行初始化，下面列出相关代码：

  1. 根据CPU个数，为根任务组root_task_group分配调度实体指针数组和运行队列指针数组。
  2. 带宽控制相关逻辑。
  3. 将根任务组root_task_group添加到全局任务组链表中，并初始化其树形结构字段。
  4. 根据每个CPU运行队列，初始化根任务组的调度实体和运行队列。
void __init sched_init(void)
{
    int i, j;
    unsigned long alloc_size = 0, ptr;

#ifdef CONFIG_FAIR_GROUP_SCHED // ---(1)
    alloc_size += 2 * nr_cpu_ids * sizeof(void **);
#endif
#ifdef CONFIG_RT_GROUP_SCHED
    alloc_size += 2 * nr_cpu_ids * sizeof(void **);
#endif

    if (alloc_size) {
        ptr = (unsigned long)kzalloc(alloc_size, GFP_NOWAIT);

#ifdef CONFIG_FAIR_GROUP_SCHED
        root_task_group.se = (struct sched_entity **)ptr;
        ptr += nr_cpu_ids * sizeof(void **);
        root_task_group.cfs_rq = (struct cfs_rq **)ptr;
        ptr += nr_cpu_ids * sizeof(void **);

#endif /* CONFIG_FAIR_GROUP_SCHED */
#ifdef CONFIG_RT_GROUP_SCHED
        root_task_group.rt_se = (struct sched_rt_entity **)ptr;
        ptr += nr_cpu_ids * sizeof(void **);
        root_task_group.rt_rq = (struct rt_rq **)ptr;
        ptr += nr_cpu_ids * sizeof(void **);

#endif /* CONFIG_RT_GROUP_SCHED */

    }

    init_rt_bandwidth(&def_rt_bandwidth, // ---(2)
        global_rt_period(), global_rt_runtime());
    init_dl_bandwidth(&def_dl_bandwidth,
        global_rt_period(), global_rt_runtime());

#ifdef CONFIG_RT_GROUP_SCHED
    init_rt_bandwidth(&root_task_group.rt_bandwidth,
        global_rt_period(), global_rt_runtime());
#endif /* CONFIG_RT_GROUP_SCHED */

#ifdef CONFIG_CGROUP_SCHED
    list_add(&root_task_group.list, &task_groups); // ---(3)
    INIT_LIST_HEAD(&root_task_group.children);
    INIT_LIST_HEAD(&root_task_group.siblings);
    autogroup_init(&init_task);

#endif /* CONFIG_CGROUP_SCHED */

    for_each_possible_cpu(i) {
        struct rq *rq = cpu_rq(i);
#ifdef CONFIG_FAIR_GROUP_SCHED // ---(4)
        root_task_group.shares = ROOT_TASK_GROUP_LOAD;
        INIT_LIST_HEAD(&rq->leaf_cfs_rq_list);

        init_cfs_bandwidth(&root_task_group.cfs_bandwidth);
        init_tg_cfs_entry(&root_task_group, &rq->cfs, NULL, i, NULL);
#endif /* CONFIG_FAIR_GROUP_SCHED */

        rq->rt.rt_runtime = def_rt_bandwidth.rt_runtime;
#ifdef CONFIG_RT_GROUP_SCHED
        init_tg_rt_entry(&root_task_group, &rq->rt, NULL, i, NULL); // ---(4)
#endif
    }
}

初始化RT任务组

该函数用来初始化RT任务组的调度实体和运行队列，当创建一个新的分组时被调用。从上面也可以看到它还被用来初始化根任务的运行队列，特别的，根任务组不需要调度实体，传入的参数为NULL；运行队列就是CPU的运行队列。

void init_tg_rt_entry(struct task_group *tg, struct rt_rq *rt_rq,
        struct sched_rt_entity *rt_se, int cpu,
        struct sched_rt_entity *parent)
{
    struct rq *rq = cpu_rq(cpu);

    rt_rq->highest_prio.curr = MAX_RT_PRIO; // ---(1)
    rt_rq->rt_nr_boosted = 0;
    rt_rq->rq = rq;
    rt_rq->tg = tg;

    tg->rt_rq[cpu] = rt_rq; // ---(2)
    tg->rt_se[cpu] = rt_se;

    if (!rt_se)
        return;
    if (!parent) // ---(3)
        rt_se->rt_rq = &rq->rt;
    else
        rt_se->rt_rq = parent->my_q;
    rt_se->my_q = rt_rq;
    rt_se->parent = parent;
    INIT_LIST_HEAD(&rt_se->run_list);
}
  1. 设置新任务组的运行队列。新的任务组还没有包含任何调度实体，其最高优先级默认取100。其rq指向CPU运行队列，tg指向任务组实例。
  2. 保存任务组的调度实体和运行队列到任务组中。
  3. 设置任务组的调度实体。只有根任务组和一级任务组的parent为NULL，它们挂到CPU的运行队列中。其它任务组的rt_rq指向其上一层任务组的运行队列。

创建分组

当新建一个分组时，CGROUP框架会调用控制器的css_alloc回调函数来分配任务组，cpu控制器的实现函数为cpu_cgroup_css_alloc()。

static struct cgroup_subsys_state *
cpu_cgroup_css_alloc(struct cgroup_subsys_state *parent_css)
{
    struct task_group *parent = css_tg(parent_css);
    struct task_group *tg;

    if (!parent) {
        /* This is early initialization for the top cgroup */
        return &root_task_group.css;
    }

    tg = sched_create_group(parent); // 创建并初始化一个新的任务组对象
    if (IS_ERR(tg))
        return ERR_PTR(-ENOMEM);

    return &tg->css;
}

创建&初始化任务组

  1. 分配task_group对象。
  2. 为任务组分配调度实体和运行队列。
struct task_group *sched_create_group(struct task_group *parent)
{
    struct task_group *tg;

    tg = kzalloc(sizeof(*tg), GFP_KERNEL); // ---(1)
    if (!tg)
        return ERR_PTR(-ENOMEM);

    if (!alloc_fair_sched_group(tg, parent)) // ---(2)
        goto err;

    if (!alloc_rt_sched_group(tg, parent))
        goto err;

    return tg;
err:
    free_sched_group(tg);
    return ERR_PTR(-ENOMEM);
}

下面以RT组调度为例看其实现：

  1. 为RT任务组分配每个CPU上的运行队列指针数组和调度实体指针数组。
  2. 分配每个CPU上的调度实体和运行队列，并对其进行初始化。
int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
{
    struct rt_rq *rt_rq;
    struct sched_rt_entity *rt_se;
    int i;

    tg->rt_rq = kzalloc(sizeof(rt_rq) * nr_cpu_ids, GFP_KERNEL); // ---(1)
    if (!tg->rt_rq)
        goto err;
    tg->rt_se = kzalloc(sizeof(rt_se) * nr_cpu_ids, GFP_KERNEL);
    if (!tg->rt_se)
        goto err;

    init_rt_bandwidth(&tg->rt_bandwidth,
        ktime_to_ns(def_rt_bandwidth.rt_period), 0);

    for_each_possible_cpu(i) { // ---(2)
        rt_rq = kzalloc_node(sizeof(struct rt_rq),
             GFP_KERNEL, cpu_to_node(i));
        if (!rt_rq)
            goto err;
        rt_se = kzalloc_node(sizeof(struct sched_rt_entity),
             GFP_KERNEL, cpu_to_node(i));
        if (!rt_se)
            goto err_free_rq;

        init_rt_rq(rt_rq, cpu_rq(i));
        rt_rq->rt_runtime = tg->rt_bandwidth.rt_runtime;
        init_tg_rt_entry(tg, rt_rq, rt_se, i, parent->rt_se[i]);
    }
    return 1;

err_free_rq:
    kfree(rt_rq);
err:
    return 0;
}

任务创建

在新任务创建完毕后，CGROUP框架会调用控制器的fork回调函数，让控制器在任务创建时执行一些逻辑，cpu控制器的实现函数为cpu_cgroup_fork()。

static void cpu_cgroup_fork(struct task_struct *task)
{
    sched_move_task(task); // 任务切换分组也是调用该函数
}

/* change task's runqueue when it moves between groups.
 *    The caller of this function should have put the task in its new group
 *    by now. This function just updates tsk->se.cfs_rq and tsk->se.parent to
 *    reflect its new group.
 */
void sched_move_task(struct task_struct *tsk)
{
    struct task_group *tg;
    int queued, running;
    unsigned long flags;
    struct rq *rq;

    rq = task_rq_lock(tsk, &flags);

    running = task_current(rq, tsk); // ---(1)
    queued = task_on_rq_queued(tsk);

    if (queued)
        dequeue_task(rq, tsk, 0);
    if (unlikely(running))
        put_prev_task(rq, tsk);

    /*
    * All callers are synchronized by task_rq_lock(); we do not use RCU
    * which is pointless here. Thus, we pass "true" to task_css_check()
    * to prevent lockdep warnings.
    */
    tg = container_of(task_css_check(tsk, cpu_cgrp_id, true),
     struct task_group, css); // ---(2)
    tg = autogroup_task_group(tsk, tg);
    tsk->sched_task_group = tg;

#ifdef CONFIG_FAIR_GROUP_SCHED
    if (tsk->sched_class->task_move_group)
        tsk->sched_class->task_move_group(tsk, queued);
else
#endif
    set_task_rq(tsk, task_cpu(tsk)); // ---(3)

    if (unlikely(running)) // ---(1)
        tsk->sched_class->set_curr_task(rq);
    if (queued)
        enqueue_task(rq, tsk, 0);

    task_rq_unlock(rq, tsk, &flags);
}

如注释所描述，调用sched_move_task()函数之前，真正的CGROUP分组相关的任务设置已经完成，该函数负责更新任务的调度实体中和组调度相关的内容：

  1. 执行该动作前，任务可能已经在CPU运行队列中，或者正在运行，那么先将其从队列中移除，设置完组调度相关内容后再将其加回去。
  2. 根据CGROUP的层级关系，找到该任务所属任务组对象，将其保存到任务的sched_task_group字段中。
  3. 调用set_task_rq()函数设置任务的调度实体中的parent为所属任务组的调度实体，xxx_rq为所属任务组的运行队列。

设置任务调度实体

set_task_rq()函数将任务的调度实体中的xx_rq和parent分别设置为所属任务组的运行队列和调度实体。

static inline void set_task_rq(struct task_struct *p, unsigned int cpu)
{
#if defined(CONFIG_FAIR_GROUP_SCHED) || defined(CONFIG_RT_GROUP_SCHED)
    struct task_group *tg = task_group(p);
#endif

#ifdef CONFIG_FAIR_GROUP_SCHED
    p->se.cfs_rq = tg->cfs_rq[cpu];
    p->se.parent = tg->se[cpu];
#endif

#ifdef CONFIG_RT_GROUP_SCHED
    p->rt.rt_rq  = tg->rt_rq[cpu];
    p->rt.parent = tg->rt_se[cpu];
#endif
}

RT调度器选择任务

在没有组调度的情况下，调度框架在调用RT的pick_next_task回调选择任务时，直接从CPU运行队列中选择优先级最高的任务即可。支持组调度后，由于每个任务组都是用独立的运行队列来管理组内调度实体的，所以任务的选择过程应该是个递归的过程，下面重新来看其中最终要的_pick_next_rt()函数实现。

static struct task_struct *_pick_next_task_rt(struct rq *rq)
{
    struct sched_rt_entity *rt_se;
    struct task_struct *p;
    struct rt_rq *rt_rq  = &rq->rt;

    do {
        rt_se = pick_next_rt_entity(rq, rt_rq); // ---(1)
        BUG_ON(!rt_se);
        rt_rq = group_rt_rq(rt_se);
    } while (rt_rq); // ---(2)

    p = rt_task_of(rt_se);
    p->se.exec_start = rq_clock_task(rq);

    return p;
}

static struct sched_rt_entity *pick_next_rt_entity(struct rq *rq,
                           struct rt_rq *rt_rq)
{
    struct rt_prio_array *array = &rt_rq->active;
    struct sched_rt_entity *next = NULL;
    struct list_head *queue;
    int idx;

    idx = sched_find_first_bit(array->bitmap);

    queue = array->queue + idx;
    next = list_entry(queue->next, struct sched_rt_entity, run_list);

    return next;
}
  1. pick_next_rt_entity()函数从参数指定的运行队列中找到优先级最高的调度实体，该调度实体可能时任务，也可能是一个任务组。
  2. group_rt_rq()函数返回调度实体的my_q，如果找到的是任务组，则返回的是该任务组的运行队列，循环会继续下一层的遍历；如果找到的是任务，那么返回为NULL，结束循环。

通过上面的遍历过程，只要每一个任务组都能够正确维护运行队列中的优先级数组，那么每次调用就都可以找到优先级最高的任务。

RT任务组优先级

如前面对RT调度器选择任务过程的分析，每个任务组都需要维护自己的优先级数组。支持组调度后，优先级数组中除了任务的调度实体外，还会有任务组的调度实体，所以也需要为任务组定义优先级。RT任务组的优先级定义为自己运行队列中优先级最高的调度实体的优先级。RT任务组的优先级保存在任务组运行队列的rt_rq.highest.curr字段中。

为了维护RT任务组的优先级，在调度实体入队和出队时需要进行优先级的更新，具体的函数为__enqueue_rt_entity()-->inc_rt_tasks()-->inc_rt_prio()和__dequeue_rt_entity()-->dec_rt_tasks()-->dec_rt_prio()。

static void
 inc_rt_prio(struct rt_rq *rt_rq, int prio)
{
    // 入队时，如果新的优先级更高则更新运行队列的最高优先级
    int prev_prio = rt_rq->highest_prio.curr;

    if (prio < prev_prio)
        rt_rq->highest_prio.curr = prio;

    inc_rt_prio_smp(rt_rq, prio, prev_prio);
}

static void dec_rt_prio(struct rt_rq *rt_rq, int prio)
{
    // 出队的是最高优先级时重新计算最高优先级。队列为空时，优先级设置为100
    int prev_prio = rt_rq->highest_prio.curr;

    if (rt_rq->rt_nr_running) {

        WARN_ON(prio < prev_prio);

        if (prio == prev_prio) {
            struct rt_prio_array *array = &rt_rq->active;
            rt_rq->highest_prio.curr = sched_find_first_bit(array->bitmap);
        }
    } else
        rt_rq->highest_prio.curr = MAX_RT_PRIO;

    dec_rt_prio_smp(rt_rq, prio, prev_prio);
}

上面的inc_rt_prio()和dec_rt_prio()仅仅维护了参数指定的运行队列的优先级，但每个CPU的运行队列中的可能有多个任务组，任何一个低层级的任务组中任务的需要入队或出队，都会影响从根任务组到其直属任务组的优先级。因此在入队和出队时需要额外的流程来维护所有层级上任务组的优先级，下面以一个虚拟的任务组结构来分析入队和出队时的任务组优先级变化。

当TaskA入队和出队时，GroupA、GroupB、GroupD的优先级都需要更新。为了简化实现流程，内核在TaskA入队过程中，按照如下步骤执行：

  1. 按照GroupB->GroupD的顺序执行出队，这样随着出队过程不断更新各任务组的优先级，出队完毕后，GroupA、GroupB、GroupD的优先级都是正确的；
  2. 按照TaskA->GroupD->GroupB的顺序执行入队，这样随着入队过程不断更新各任务组的优先级，入队完毕后，GroupA、GroupB、GroupD的优先级都是正确的。

内核在TaskA出队过程中，按照如下步骤执行：

  1. 按照GroupB->GroupD->TaskA的顺序执行出队，这样随着出队过程不断更新各任务组的优先级，出队完毕后，GroupA、GroupB、GroupD的优先级都是正确的。
  2. 按照GroupD->GroupB的顺序执行入队，这样随着入队过程不断更新各任务组的优先级，入队完毕后，GroupA、GroupB、GroupD的优先级都是正确的。

这么做的好处是可以简化每个任务组在执行入队和出队时的处理逻辑，它们只需要处理好自己直接管理的调度实体即可，不需要操心祖先任务组的优先级更新。

调度实体入队

enqueue_rt_entity()函数负责将一个调度实体入队，该调度实体可以是任务也可以是任务组。任务入队函数enqueue_task_rt()最后也是调用该函数将任务加入队列中的。

static void enqueue_rt_entity(struct sched_rt_entity *rt_se, bool head)
{
    struct rq *rq = rq_of_rt_se(rt_se);

    dequeue_rt_stack(rt_se); // 按照层级从高到低的顺序依次出队
    for_each_sched_rt_entity(rt_se)
        // 按照层级从低到高的顺序依次入队
        __enqueue_rt_entity(rt_se, head);
    enqueue_top_rt_rq(&rq->rt); // 重新设置CPU运行队列的可运行任务个数
}

dequeue_rt_stack()

#define for_each_sched_rt_entity(rt_se) \
    for (; rt_se; rt_se = rt_se->parent)
 
static void dequeue_rt_stack(struct sched_rt_entity *rt_se)
{
    struct sched_rt_entity *back = NULL;

    // 通过back指针得到一个从GroupB->GroupD->TaskA的调度实体链表
    for_each_sched_rt_entity(rt_se) {
        rt_se->back = back;
        back = rt_se;
    }

    // rt_rq_of_se(back)得到的是CPU运行队列，所以直接会减去所有的任务
    dequeue_top_rt_rq(rt_rq_of_se(back));

    // 按照GroupB->GroupD->TaskA的顺序，将调度实体从所属运行队列中移除
    for (rt_se = back; rt_se; rt_se = rt_se->back) {
        if (on_rt_rq(rt_se))
            __dequeue_rt_entity(rt_se);
    }
}

调度实体出队

dequeue_rt_entity()函数负责将一个调度实体出队，该调度实体可以是任务也可以是任务组。任务入队函数dequeue_task_rt()最后也是调用该函数将任务从队列中移除的。

static void dequeue_rt_entity(struct sched_rt_entity *rt_se)
{
    struct rq *rq = rq_of_rt_se(rt_se);

    dequeue_rt_stack(rt_se); // 按照层级从高到低的顺序依次出队
    // 按照层级从低到高的顺序依次入队，这个过程只将非空的任务组调度实体入队，
    // 所以步骤一中移除的最底层调度实体不会重新入队
    for_each_sched_rt_entity(rt_se) {
        struct rt_rq *rt_rq = group_rt_rq(rt_se);

        if (rt_rq && rt_rq->rt_nr_running)
            __enqueue_rt_entity(rt_se, false);
    }
    enqueue_top_rt_rq(&rq->rt); // 重新设置CPU运行队列的可运行任务个数
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/135821.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Linux应用开发基础知识——LCD上的矢量字体Freetype(六)

Linux应用开发基础知识——LCD上的矢量字体Freetype(六)

前言&#xff1a; 使用 buildroot 来给 ARM 板编译程序、编译库会很简单&#xff0c;以后系统讲解 buildroot 时再使用 buildroot&#xff0c;现在我们还是手工交叉编译 freetype&#xff0c;这种方法在编译、安装一些小程序时很有用。 Freetype 是开源的字体引擎库&#xff0c…
阅读更多...
Java13新增特性

Java13新增特性

前言 前面的文章&#xff0c;我们对Java9、Java10、Java11、Java12 的特性进行了介绍&#xff0c;对应的文章如下 Java9新增特性 Java10新增特性 Java11新增特性 Java12新增特性 今天我们来一起看一下Java13这个版本的一些重要信息 版本介绍 Java 13 是在 2019 年 9 月 17 日…
阅读更多...
recycleView（三）动态修改背景色

recycleView（三）动态修改背景色

效果图 1.关键代码 1. // 定义一个变量来记录滑动的距离var scrollDistance 0// 在RecycleView的滑动监听器中更新滑动的距离binding.recyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener() {override fun onScrolled(recyclerView: RecyclerView, …
阅读更多...
PCB知识补充

PCB知识补充

系列文章目录 文章目录 系列文章目录参考文献PCB知识互连线电阻过孔/铜箔电流能力铜箔载流能力过孔载流能力 热设计电磁兼容及部分要求 参考文献 [1]牛森,张敏娟,银子燕.高速PCB多板互联的电源完整性分析[J].单片机与嵌入式系统应用,2023,23(09). [2]陈之秀,刘洋,张涵舒等.高…
阅读更多...
通用结构化剪枝DepGraph

通用结构化剪枝DepGraph

文章目录 0. 前言一. 第一部分： Torch-Pruning1.1 传统的剪枝流程 - ResNet-18结构化剪枝1.2 Torch-Pruning剪枝 - ResNet-18结构化剪枝1.3 Torch-Pruning剪枝 - 遍历所有分组1.4 Torch-Pruning剪枝 - 剪枝器 High-level Pruners1.5 Torch-Pruning剪枝 - 拓展到更复杂的神经网…
阅读更多...
【递归】求根节点到叶节点数字之和（Java版）

【递归】求根节点到叶节点数字之和（Java版）

目录 1.题目解析 2.讲解算法原理 3.代码 1.题目解析 LCR 049. 求根节点到叶节点数字之和 给定一个二叉树的根节点 root &#xff0c;树中每个节点都存放有一个 0 到 9 之间的数字。 每条从根节点到叶节点的路径都代表一个数字&#xff1a; 例如&#xff0c;从根节点到叶节点…
阅读更多...
No179.精选前端面试题，享受每天的挑战和学习

No179.精选前端面试题，享受每天的挑战和学习

🤍 前端开发工程师（主业）、技术博主（副业）、已过CET6 🍨 阿珊和她的猫_CSDN个人主页 🕠 牛客高级专题作者、在牛客打造高质量专栏《前端面试必备》 🍚 蓝桥云课签约作者、已在蓝桥云课上架的前后端实战课程《Vue.js 和 Egg.js 开发企业级健康管理项目》、《带你从入…
阅读更多...
开发者测试2023省赛--UnrolledLinkedList测试用例

开发者测试2023省赛--UnrolledLinkedList测试用例

测试结果 官方提交结果 EclEmma PITest 被测文件UnrolledLinkedList.java /** This source code is placed in the public domain. This means you can use it* without any restrictions.*/package net.mooctest;import java.util.AbstractList; import java.util.Collectio…
阅读更多...
牛客网刷题笔记231112 最小k位数+二叉树层序遍历+SQL异常邮件概率

牛客网刷题笔记231112 最小k位数+二叉树层序遍历+SQL异常邮件概率

算法题牛客网NC119 最小的k个数 题目&#xff1a; 用了一下python列表的便利&#xff0c;不知道在面试时允许用不。当然最简单的方法其实是直接sort()一下取前k位数即可。本次写的思路如下&#xff1a; 用一个最大容量为k的列表存储结果&#xff0c;遍历n个元素&#xff0c;当…
阅读更多...
Python基础入门例程52-NP52 累加数与平均值(循环语句)

Python基础入门例程52-NP52 累加数与平均值(循环语句)

最近的博文&#xff1a; Python基础入门例程51-NP51 列表的最大与最小(循环语句)-CSDN博客 Python基础入门例程50-NP50 程序员节&#xff08;循环语句&#xff09;-CSDN博客 Python基础入门例程49-NP49 字符列表的长度-CSDN博客 目录 最近的博文&#xff1a; 描述 输入描…
阅读更多...
（离散数学）命题及命题的真值

（离散数学）命题及命题的真值

答案&#xff1a; &#xff08;5&#xff09;不是命题&#xff0c;因为真值不止一个 &#xff08;6&#xff09;不是命题&#xff0c;因为不是陈述句 &#xff08;7&#xff09;不是命题&#xff0c;因为不是陈述句 &#xff08;8&#xff09;不是命题&#xff0c;真值不唯一
阅读更多...
Reeds-Shepp曲线

Reeds-Shepp曲线

汽车都有一个最小转向半径&#xff0c;Reeds-Shepp曲线由几段半径固定的圆弧和一段直线段拼接组成&#xff0c;而且圆弧的半径就是汽车的最小转向半径。从起始点到目标点的路径长度是指汽车中心运动轨迹的长度&#xff0c;也就是所有圆弧的弧长和直线段的长度之和。 当环境中…
阅读更多...
顺序查找和折半查找

顺序查找和折半查找

顺序查找的算法思想 顺序查找&#xff0c;又叫“线性查找”&#xff0c;通常用于线性表 算法思想&#xff1a;从头到脚挨个找 顺序查找的实现 typedef struct{ //查找表的数据结构&#xff08;顺序表&#xff09;ElemType *elem; //动态数组基址int TableLen; //表的长度 }S…
阅读更多...
华为ensp：rip宣告

华为ensp：rip宣告

ip全部配置好 R1 进入r1视图模式 rip network 192.168.1.0 network 1.0.0.0 R2 进入r2视图模式 rip network 192.168.2.0 network 1.0.0.0 这样就完成了宣告 display ip routing-table 查看路由表
阅读更多...
Leetcode—191.位1的个数【简单】

Leetcode—191.位1的个数【简单】

2023每日刷题&#xff08;二十七&#xff09; Leetcode—191.位1的个数 实现代码 int hammingWeight(uint32_t n) {int ans 0;for(int i 0; i < 32; i) {if(n & ((long long)1 << i)) {ans;}}return ans; }运行结果 翻转比特1思路 就解法一的代码实现来说&am…
阅读更多...
零基础学习Matlab，适合入门级新手，了解Matlab

零基础学习Matlab，适合入门级新手，了解Matlab

一、认识Matlab Matlab安装请参见博客 安装步骤 1.界面 2.清空环境变量及命令 &#xff08;1&#xff09;clear all &#xff1a;清除Workspace中的所有变量 &#xff08;2&#xff09;clc&#xff1a;清除Command Window中的所有命令 二、Matlab基础 1.变量命名规则 &a…
阅读更多...
Django的ORM操作

Django的ORM操作

文章目录 1.ORM操作1.1 表结构1.1.1 常见字段和参数1.1.2 表关系 2.ORM2.1 基本操作2.2 连接数据库2.3 基础增删改查2.3.1 增加2.3.2 查找2.3.4 删除2.3.4 修改 1.ORM操作 orm&#xff0c;关系对象映射&#xff0c;本质翻译的。 1.1 表结构 实现&#xff1a;创建表、修改表、…
阅读更多...
深度学习之基于Pytorch框架的MNIST手写数字识别

深度学习之基于Pytorch框架的MNIST手写数字识别

欢迎大家点赞、收藏、关注、评论啦 &#xff0c;由于篇幅有限&#xff0c;只展示了部分核心代码。 文章目录 一项目简介 二、功能三、系统四. 总结 一项目简介 MNIST是一个手写数字识别的数据集&#xff0c;是深度学习中最常用的数据集之一。基于Pytorch框架的MNIST手写数字识…
阅读更多...
k8s-实验部署 1

k8s-实验部署 1

1、k8s集群部署 更改所有主机名称和解析 开启四台实验主机&#xff0c;k8s1 仓库&#xff1b;k8s2 集群控制节点&#xff1b; k8s3 和k8s4集群工作节点&#xff1b; 集群环境初始化 使用k8s1作为仓库&#xff0c;将所有的镜像都保存在本地&#xff0c;不要将集群从外部走 仓库…
阅读更多...
Mac Qt 5.13.2无法加载文件

Mac Qt 5.13.2无法加载文件

在Mac OS 14.0系统上&#xff0c;离线安装了Qt5.13.2&#xff0c;但是新建一个工程&#xff0c;却无法正常使用&#xff0c;只能加载出pro文件&#xff0c;其他文件都加载不出来&#xff0c;提示错误&#xff1a;Project ERROR: failed to parse default search paths from com…
阅读更多...
最新文章

Copyright @ 2022~2023