精华内容
下载资源
问答
  • linux rt补丁 实时进程,基于RTLinux的分布式实时进程通信技术的研究与实现
    2021-05-15 12:22:16

    摘要:

    随着计算机技术的高速发展,实时信息处理系统已经被逐步应用于各个领域.分布式实时操作系统为这些实时信息处理系统提供了良好的运行平台,然而由于不同领域的应用对实时性的要求不尽相同,因此很难找到一种分布式实时操作系统可以完全满足这些不同的需求.在这种情况下,针对不同应用领域的特点来开发具有自主知识产权的分布式实时操作系统是解决这个问题较好的途径. RTLinux是一个在Linux基础上改造而来的具有硬实时性能的单机实时操作系统,它具有开放的源码,这有利于在RTLinux的基础上开发分布式实时操作系统.进程通信机制是分布式实时操作系统的核心技术之一,在对RTLinux进行分析和研究的基础上,采用远程过程调用模型和组通信模型对RTLinux进程通信机制进行分布式实时化改造.改造后的进程通信机制主要包括:端口操纵,端口动态管理,端口接收服务和实时消息队列管理等模块.这些模块分别从进程通信的缓冲区管理,消息队列的排队管理和消息接收服务等方面对RTLinux的进程通信机制进行实时性改造,提高了RTLinux进程通信的实时性.另外,通过引入全局信息表管理,全局信息广播,全局信息查询等技术,为用户提供了透明的进程通信函数调用接口. 测试表明,改进后进程通信的通信延迟处在一个可预测的范围之内,同时也体现出了在消息排队过程中优先级排队算法的优越性和信号量的同步协调功能.

    展开

    更多相关内容
  • 实时调度策略介绍实时进程将得到优先调用,实时进程根据实时优先级决定调度权值,普通分时进程则通过nice和counter值决定权值,nice越小,counter越大,被调度的概率越大,也就是曾经使用了cpu最少的进程将会得到...

    实时调度策略介绍

    实时进程将得到优先调用,实时进程根据实时优先级决定调度权值,普通分时进程则通过nice和counter值决定权值,nice越小,counter越大,被调度的概率越大,也就是曾经使用了cpu最少的进程将会得到优先调度。实时任务按照可抢占优先级调度算法进行,就绪态的实时任务可以立即抢占非实时任务。

    1,SCHED_FIFO:First Input First Output,优先级范围1-99(最大)

    SCHED_FIFO一旦占用cpu则一直运行。一直运行直到有更高优先级任务到达或自己放弃。

    如果有相同优先级的实时进程(根据优先级计算的调度权值是一样的)已经准备好,FIFO时必须等待该进程主动放弃后才可以运行这个优先级相同的任务。而RR可以让每个任务都执行一段时间。

    2,SCHED_RR:基于FIFO基础上的Round Robin时间片轮转,先入先出当采用SHCED_RR策略的进程的时间片用完,系统将重新分配时间片,并置于就绪队列尾。将进程放在队列尾保证了所有具有相同优先级的RR任务的调度公平。

    3,SCHED_DEADLINE:该调度策略采用Global Earliest Deadline First(GEDF)算法,最早要到期的任务将被以最高优先级调度和分配CPU。根据此策略调度的任务可以抢占使用SCED FIFO、SCED RR或非实时调度的任何任务。参考https://lwn.net/Articles/743740/和https://blog.csdn.net/zhuyong006/article/details/80980502

    https://blog.csdn.net/xiaofeng_yan/article/details/48246101

    调度参数(ns纳秒单位):

    runtime:任务需要CPU执行的时长,要考虑最坏/最慢情况下的最大时长,要小于deadline

    period:任务执行的周期,即两次任务开始的时间间隔

    deadline:任务必须在该时长内执行完,不大于period,是从period开始时刻计算时长

    调度算法介绍

    所有任务都采用Linux分时调度策略时:

    Linux采用CFS(Completely Fair Scheduler)完全公平调度算法实现分时进程的CPU资源分配,注意    :非实时线程priority(100-139)由内核动态调控,不能人为设置,可以用修改nice值(-20~19 越低的值越高的优先级,这个在计算虚拟时间的时候放在分母上),从而间接影响优先级,PRI(new) = PRI(old) + nice

    1)创建任务指定采用分时调度策略,并指定优先级nice值(-20~19)。

    2)将根据每个任务的nice值确定在cpu上的执行时间(counter)。

    3)如果没有等待资源,则将该任务加入到就绪队列中。

    4)调度程序遍历就绪队列中的任务,通过对每个任务动态优先级的计算(counter+20-nice)结果,选择

    计算结果最大的一个去运行,当这 个时间片用完后(counter减至0)或者主动放弃cpu时,该任务将被放在

    就绪队列末尾(时间片用完)或等待队列(因等待资源而放弃cpu)中。

    5)此时调度程序重复上面计算过程,转到第4步。

    6)当调度程序发现所有就绪任务计算所得的权值都为不大于0时,重复第2步。

    所有任务都采用FIFO的调度策略时:

    1)创建进程时指定采用FIFO,并设置实时优先级rt_priority(1-99)。

    2)如果没有等待资源,则将该任务加入到就绪队列中。

    3)调度程序遍历就绪队列,根据实时优先级计算调度权值(1000+rt_priority),选择权值最高的任务使用cpu,该FIFO任务将一直占有cpu直到有优先级更高的任务就绪(即使优先级相同也不行)或者主动放弃(等待资源)。

    4)调度程序发现有优先级更高的任务到达(高优先级任务可能被中断或定时器任务唤醒,再或被当前运行的任务唤醒,等等),则调度程序立即在当前任务 堆栈中保存当前cpu寄存器的所有数据,重新从高优先级任务的堆栈中加载寄存器数据到cpu,此时高优先级的任务开始运行。重复第3步。

    5)如果当前任务因等待资源而主动放弃cpu使用权,则该任务将从就绪队列中删除,加入等待队列,此时重复第3步。

    所有任务都采用RR调度策略(轮转法调度)时:

    1)创建任务时指定调度参数为RR,并设置任务的实时优先级和nice值(nice值将会转换为该任务的时间片的长度)。

    2)如果没有等待资源,则将该任务加入到就绪队列中。

    3)调度程序遍历就绪队列,根据实时优先级计算调度权值(1000+rt_priority),选择权值最高的任务使用cpu。,

    4)如果就绪队列中的RR任务时间片为0(RR时间片是100ms),则会根据nice值设置该任务的时间片,同时将该任务放入就绪5队列的末尾。重复步骤3。

    5)当前任务由于等待资源而主动退出cpu,则其加入等待队列中。重复步骤3。

    所有任务都采用SCHED_DEADLINE调度策略时:

    该调度策略在目前的 Linux 内核里面属于优先级最高的调度类,也就是说假设系统上面存在多个调度类,那么每次重新调度的时候,都是先从该调度类下面去找到一个可以投入运行的进程进行调度。归属于该调度类的进程其归一化优先级都是 -1,在该调度类内部不再区分多个优先级,统一归为 -1.

    1)创建任务时指定调度参数为DEADLINE,设定runtime、period、deadline参数。

    2)如果没有等待资源,则将该任务加入到就绪队列中。

    3)调度程序遍历就绪列表,根据deadline到期时间,选择最短的任务执行

    4)执行最长时间片由runtime指定,过时没有执行完也会被收回CPU资源

    5)将任务加入到就绪队列中,重复步骤3

    系统中既有分时调度,又有实时RR时间片轮转调度、FIFO先进先出调度和DEADLINE调度:

    1)调度系统首先查看是否有DEADLINE任务将要到期,如有则会抢占CPU资源执行DEADLINE任务,即使当前CPU正在执行FIFO或RR任务。

    2)RR调度和FIFO调度的进程属于实时进程,以分时调度的进程是非实时进程。

    3)当实时进程准备就绪后,如果当前cpu正在运行非实时进程,则实时进程立即抢占非实时进程。

    普通进程完全捞不到CPU资源也不完全对,后来LINUX增加组调度策略后,有/proc/sys/kernel/sched_rt_period_us和/proc/sys/kernel/sched_rt_runtime_us两个参数,这两个参数表示的含义是:在sched_rt_peroid_us的周期内,所有的实时进程运行时间之和不得超过sched_rt_runtime_us。 默认值为1秒和0.95秒换句话说,在1秒的周期以内,所有实时进程运行时间之和不得超过0.95秒,剩下的0.5秒钟留给普通进程。

    3)RR进程和FIFO进程都采用实时优先级做为调度的权值标准,RR是FIFO的一个延伸。FIFO时,如果两个进程的优先级一样,则这两个优先级一样的进程具体执行哪一个是由其在队列中的未知决定的,这样导致一些不公正性,如果将两个优先级一样的任务的调度策略都设为RR,则保证了这两个任务可以循环执行,保证了公平。

    展开全文
  • UNIX / LINUX总体优先级的范围为140个值,而nice值使进程可以映射到范围的最后一部分(从100到139)。 该公式使从0到99的值不可用,这将对应于负PR级别(从-100到-1)。 为了能够访问这些值,该过程应称为“实时”...

    简答

    99位将是实时优先级的获胜者。

    PR是优先级(-100至40)。 PR越低,该过程的优先级越高。

    PR计算如下:

    对于正常过程:PR = 20-NI(NI很好,范围从-20到19)

    对于实时过程:PR =-1-real_time_priority(real_time_priority的范围是1到99)

    答案很长

    有两种类型的过程,正常过程和实时过程对于普通的(并且仅适用于那些),nice的应用如下:

    好啊

    “ niceness”标度从-20到19,而-20是最高优先级,19是最低优先级。 优先级计算如下:

    PR = 20 + NI

    其中NI为好级别,PR为优先级别。 正如我们所看到的,-20实际上映射为0,而19映射为39。

    缺省情况下,程序的nice值是0位,root用户可以使用以下命令来午餐带有指定nice值的程序:

    nice -n ./myProgram

    即时的

    我们可以走得更远。 好优先级实际上用于用户程序。 UNIX / LINUX总体优先级的范围为140个值,而nice值使进程可以映射到范围的最后一部分(从100到139)。 该公式使从0到99的值不可用,这将对应于负PR级别(从-100到-1)。 为了能够访问这些值,该过程应称为“实时”。

    LINUX环境中有5个调度策略,可以通过以下命令显示:

    chrt -m

    它将显示以下列表:

    1. SCHED_OTHER the standard round-robin time-sharing policy

    2. SCHED_BATCH for "batch" style execution of processes

    3. SCHED_IDLE for running very low priority background jobs.

    4. SCHED_FIFO a first-in, first-out policy

    5. SCHED_RR a round-robin policy

    调度过程可以分为2组,正常调度策略(1至3)和实时调度策略(4和5)。实时过程将始终具有比常规过程更高的优先级。 可以使用以下命令来调用实时过程(该示例是如何声明SCHED_RR策略):

    chrt --rr ./myProgram

    为了获得实时过程的PR值,使用以下公式:

    PR = -1-rt_prior

    其中rt_prior对应于1到99之间的优先级。因此,比其他进程具有更高优先级的进程将是编号为99的进程。

    重要的是要注意,对于实时过程,不会使用nice值。

    要查看进程的当前“良好”和PR值,可以执行以下命令:

    top

    显示以下输出:

    L5Q72.png

    在图中显示了PR和NI值。 最好注意PR值-51与实时值相对应的过程。 也有一些过程的PR值表示为“ rt”。 该值实际上对应于-100的PR值。

    展开全文
  • 通过该源码,我们来了解下Kernel在进行进程调度的时候,RT进程为何优于CFS进程调度。 一、进程调度流程 代码路径:/kernel/sched/core.c 相关进程调度流程如下: 二、代码梳理 2.1 调度器函数 /kernel/...

    写在前面:

    改代码分析,基于Android的kernel源码。通过该源码,我们来了解下Kernel在进行进程调度的时候,RT进程为何优于CFS进程调度。

    一、进程调度流程

    代码路径:/kernel/sched/core.c,这部分kernel代码来自http://androidxref.com/kernel_3.18/.

    相关进程调度流程如下:

    二、代码梳理

    2.1 调度器函数

    /kernel/sched/core.c

        static void __sched __schedule(void)
    2766{
    2767	struct task_struct *prev, *next;
    2768	unsigned long *switch_count;
    2769	struct rq *rq;
    2770	int cpu;
    2771
    2772need_resched:
    2773	preempt_disable();
    2774	cpu = smp_processor_id();
    2775	rq = cpu_rq(cpu);
    2776	rcu_note_context_switch(cpu);
    2777	prev = rq->curr;
    2778
    2779	schedule_debug(prev);
    2780
    2781	if (sched_feat(HRTICK))
    2782		hrtick_clear(rq);
    2783
    2784	/*
    2785	 * Make sure that signal_pending_state()->signal_pending() below
    2786	 * can't be reordered with __set_current_state(TASK_INTERRUPTIBLE)
    2787	 * done by the caller to avoid the race with signal_wake_up().
    2788	 */
    2789	smp_mb__before_spinlock();
    2790	raw_spin_lock_irq(&rq->lock);
    2791
    2792	switch_count = &prev->nivcsw;
    2793	if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
    2794		if (unlikely(signal_pending_state(prev->state, prev))) {
    2795			prev->state = TASK_RUNNING;
    2796		} else {
    2797			deactivate_task(rq, prev, DEQUEUE_SLEEP);
    2798			prev->on_rq = 0;
    2799
    2800			/*
    2801			 * If a worker went to sleep, notify and ask workqueue
    2802			 * whether it wants to wake up a task to maintain
    2803			 * concurrency.
    2804			 */
    2805			if (prev->flags & PF_WQ_WORKER) {
    2806				struct task_struct *to_wakeup;
    2807
    2808				to_wakeup = wq_worker_sleeping(prev, cpu);
    2809				if (to_wakeup)
    2810					try_to_wake_up_local(to_wakeup);
    2811			}
    2812		}
    2813		switch_count = &prev->nvcsw;
    2814	}
    2815
    2816	if (task_on_rq_queued(prev) || rq->skip_clock_update < 0)
    2817		update_rq_clock(rq);
    2818
    2819	next = pick_next_task(rq, prev);
    2820	clear_tsk_need_resched(prev);
    2821	clear_preempt_need_resched();
    2822	rq->skip_clock_update = 0;
    2823
    2824	if (likely(prev != next)) {
    2825		rq->nr_switches++;
    2826		rq->curr = next;
    2827		++*switch_count;
    2828
    2829		context_switch(rq, prev, next); /* unlocks the rq */
    2830		/*
    2831		 * The context switch have flipped the stack from under us
    2832		 * and restored the local variables which were saved when
    2833		 * this task called schedule() in the past. prev == current
    2834		 * is still correct, but it can be moved to another cpu/rq.
    2835		 */
    2836		cpu = smp_processor_id();
    2837		rq = cpu_rq(cpu);
    2838	} else
    2839		raw_spin_unlock_irq(&rq->lock);
    2840
    2841	post_schedule(rq);
    2842
    2843	sched_preempt_enable_no_resched();
    2844	if (need_resched())
    2845		goto need_resched;
    2846}

    2.2 选择最高优先级的进程进行执行

    /kernel/sched/core.c

    2692static inline struct task_struct *
    2693pick_next_task(struct rq *rq, struct task_struct *prev)
    2694{
    2695	const struct sched_class *class = &fair_sched_class;
    2696	struct task_struct *p;
    2697
    2698	/*
    2699	 * Optimization: we know that if all tasks are in
    2700	 * the fair class we can call that function directly:
    2701	 */
    2702	if (likely(prev->sched_class == class &&
    2703		   rq->nr_running == rq->cfs.h_nr_running)) {//如果当前任务队列没有RT任务,则选择普通进程
    2704		p = fair_sched_class.pick_next_task(rq, prev);
    2705		if (unlikely(p == RETRY_TASK))
    2706			goto again;
    2707
    2708		/* assumes fair_sched_class->next == idle_sched_class */
    2709		if (unlikely(!p))
    2710			p = idle_sched_class.pick_next_task(rq, prev);
    2711
    2712		return p;
    2713	}
    2714
    2715again:
    2716	for_each_class(class) {
    2717		p = class->pick_next_task(rq, prev);//从这里来看,只要有rt进程就不会接着继续找了
    2718		if (p) {
    2719			if (unlikely(p == RETRY_TASK))
    2720				goto again;
    2721			return p;
    2722		}
    2723	}
    2724
    2725	BUG(); /* the idle class will always have a runnable task */
    2726}

    2.3 调度类轮询

    1 Stop调度器

    优先级最高的调度器,可以抢占其他所有进程,不能被其他进程抢占;

    //轮询调度类,首先从stop_schd_class开始;stop调度器作为最高优先级调度器,可以抢占其他所有进程。Stop调度器仅由内核使用,用户无法选择,这里不做讨论。
    1150#define sched_class_highest (&stop_sched_class)
    1151#define for_each_class(class) \
    1152   for (class = sched_class_highest; class; class = class->next)
    1153
    1154extern const struct sched_class stop_sched_class;
    1155extern const struct sched_class dl_sched_class;
    1156extern const struct sched_class rt_sched_class;
    1157extern const struct sched_class fair_sched_class;
    1158extern const struct sched_class idle_sched_class;
    109/*
    110 * Simple, special scheduling class for the per-CPU stop tasks:
    111 */
    112const struct sched_class stop_sched_class = {
    113	.next			= &dl_sched_class,
    114
    115	.enqueue_task		= enqueue_task_stop,
    116	.dequeue_task		= dequeue_task_stop,
    117	.yield_task		= yield_task_stop,
    118
    119	.check_preempt_curr	= check_preempt_curr_stop,
    120
    121	.pick_next_task		= pick_next_task_stop,
    122	.put_prev_task		= put_prev_task_stop,
    123
    124#ifdef CONFIG_SMP
    125	.select_task_rq		= select_task_rq_stop,
    126#endif
    127
    128	.set_curr_task          = set_curr_task_stop,
    129	.task_tick		= task_tick_stop,
    130
    131	.get_rr_interval	= get_rr_interval_stop,
    132
    133	.prio_changed		= prio_changed_stop,
    134	.switched_to		= switched_to_stop,
    135	.update_curr		= update_curr_stop,
    136};

    2 dl调度器

    使用红黑树,把进程按照绝对截止日期进行排序,选择最小的进程运行;

    1676const struct sched_class dl_sched_class = {
    1677	.next			= &rt_sched_class,
    1678	.enqueue_task		= enqueue_task_dl,
    1679	.dequeue_task		= dequeue_task_dl,
    1680	.yield_task		= yield_task_dl,
    1681
    1682	.check_preempt_curr	= check_preempt_curr_dl,
    1683
    1684	.pick_next_task		= pick_next_task_dl,
    1685	.put_prev_task		= put_prev_task_dl,
    1686
    1687#ifdef CONFIG_SMP
    1688	.select_task_rq		= select_task_rq_dl,
    1689	.set_cpus_allowed       = set_cpus_allowed_dl,
    1690	.rq_online              = rq_online_dl,
    1691	.rq_offline             = rq_offline_dl,
    1692	.post_schedule		= post_schedule_dl,
    1693	.task_woken		= task_woken_dl,
    1694#endif
    1695
    1696	.set_curr_task		= set_curr_task_dl,
    1697	.task_tick		= task_tick_dl,
    1698	.task_fork              = task_fork_dl,
    1699	.task_dead		= task_dead_dl,
    1700
    1701	.prio_changed           = prio_changed_dl,
    1702	.switched_from		= switched_from_dl,
    1703	.switched_to		= switched_to_dl,
    1704
    1705	.update_curr		= update_curr_dl,
    1706};

    3 rt调度器

    2102const struct sched_class rt_sched_class = {
    2103	.next			= &fair_sched_class,
    2104	.enqueue_task		= enqueue_task_rt,
    2105	.dequeue_task		= dequeue_task_rt,
    2106	.yield_task		= yield_task_rt,
    2107
    2108	.check_preempt_curr	= check_preempt_curr_rt,
    2109
    2110	.pick_next_task		= pick_next_task_rt,
    2111	.put_prev_task		= put_prev_task_rt,
    2112
    2113#ifdef CONFIG_SMP
    2114	.select_task_rq		= select_task_rq_rt,
    2115
    2116	.set_cpus_allowed       = set_cpus_allowed_rt,
    2117	.rq_online              = rq_online_rt,
    2118	.rq_offline             = rq_offline_rt,
    2119	.post_schedule		= post_schedule_rt,
    2120	.task_woken		= task_woken_rt,
    2121	.switched_from		= switched_from_rt,
    2122#endif
    2123
    2124	.set_curr_task          = set_curr_task_rt,
    2125	.task_tick		= task_tick_rt,
    2126
    2127	.get_rr_interval	= get_rr_interval_rt,
    2128
    2129	.prio_changed		= prio_changed_rt,
    2130	.switched_to		= switched_to_rt,
    2131
    2132	.update_curr		= update_curr_rt,
    2133};

    4 cfs调度器

    采用完全公平调度算法的调度器

    7929/*
    7930 * All the scheduling class methods:
    7931 */
    7932const struct sched_class fair_sched_class = {
    7933	.next			= &idle_sched_class,
    7934	.enqueue_task		= enqueue_task_fair,
    7935	.dequeue_task		= dequeue_task_fair,
    7936	.yield_task		= yield_task_fair,
    7937	.yield_to_task		= yield_to_task_fair,
    7938
    7939	.check_preempt_curr	= check_preempt_wakeup,
    7940
    7941	.pick_next_task		= pick_next_task_fair,
    7942	.put_prev_task		= put_prev_task_fair,
    7943
    7944#ifdef CONFIG_SMP
    7945	.select_task_rq		= select_task_rq_fair,
    7946	.migrate_task_rq	= migrate_task_rq_fair,
    7947
    7948	.rq_online		= rq_online_fair,
    7949	.rq_offline		= rq_offline_fair,
    7950
    7951	.task_waking		= task_waking_fair,
    7952#endif
    7953
    7954	.set_curr_task          = set_curr_task_fair,
    7955	.task_tick		= task_tick_fair,
    7956	.task_fork		= task_fork_fair,
    7957
    7958	.prio_changed		= prio_changed_fair,
    7959	.switched_from		= switched_from_fair,
    7960	.switched_to		= switched_to_fair,
    7961
    7962	.get_rr_interval	= get_rr_interval_fair,
    7963
    7964	.update_curr		= update_curr_fair,
    7965
    7966#ifdef CONFIG_FAIR_GROUP_SCHED
    7967	.task_move_group	= task_move_group_fair,
    7968#endif
    7969};

    如果没有rt进程,那么在cfs调度器队列中的进程是通过最小虚拟运行时间(vruntime值最小的进程。 CFS使用红黑树组织就绪队列,因此可以快速找到vruntime值最小的那个进程,只需要查找树中最左侧的叶子节点即可)来选择执行进程的。

    且CFS调度器通过check_preempt_tick()函数,来根据当前进程已经运行的时间,判断是否需要将进程thread info结构体的flag通过resched_curr设置为TIF_NEED_RESCHED。这样在执行完本次时钟中断后(即从handle irq返回后),根据需要进行重新调度。

    /kernel/sched/fair.c

    2941/*
    2942 * Preempt the current task with a newly woken task if needed:
    2943 */
    2944static void
    2945check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
    2946{
    2947	unsigned long ideal_runtime, delta_exec;
    2948	struct sched_entity *se;
    2949	s64 delta;
    2950
    2951	ideal_runtime = sched_slice(cfs_rq, curr);//计算调度周期
    2952	delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
    2953	if (delta_exec > ideal_runtime) {
    2954		resched_curr(rq_of(cfs_rq));
    2955		/*
    2956		 * The current task ran long enough, ensure it doesn't get
    2957		 * re-elected due to buddy favours.
    2958		 */
    2959		clear_buddies(cfs_rq, curr);
    2960		return;
    2961	}
    2962
    2963	/*
    2964	 * Ensure that a task that missed wakeup preemption by a
    2965	 * narrow margin doesn't have to wait for a full slice.
    2966	 * This also mitigates buddy induced latencies under load.
    2967	 */
    2968	if (delta_exec < sysctl_sched_min_granularity)
    2969		return;
    2970
    2971	se = __pick_first_entity(cfs_rq);
    2972	delta = curr->vruntime - se->vruntime;
    2973
    2974	if (delta < 0)
    2975		return;
    2976
    2977	if (delta > ideal_runtime)
    2978		resched_curr(rq_of(cfs_rq));
    2979}

    注意:我们通过“zcat /proc/config.gz”命令来看下当前版本中内核的配置中CONFIG_HZ_100=y了解到,当前cpu是每10ms触发一次时钟中断。

    5 idle调度器

    空闲调度器,每个cpu都会有个idle线程,当没有其他进程可调度时,运行idle线程。

    82/*
    83 * Simple, special scheduling class for the per-CPU idle tasks:
    84 */
    85const struct sched_class idle_sched_class = {
    86	/* .next is NULL */
    87	/* no enqueue/yield_task for idle tasks */
    88
    89	/* dequeue is not valid, we print a debug message there: */
    90	.dequeue_task		= dequeue_task_idle,
    91
    92	.check_preempt_curr	= check_preempt_curr_idle,
    93
    94	.pick_next_task		= pick_next_task_idle,
    95	.put_prev_task		= put_prev_task_idle,
    96
    97#ifdef CONFIG_SMP
    98	.select_task_rq		= select_task_rq_idle,
    99#endif
    100
    101	.set_curr_task          = set_curr_task_idle,
    102	.task_tick		= task_tick_idle,
    103
    104	.get_rr_interval	= get_rr_interval_idle,
    105
    106	.prio_changed		= prio_changed_idle,
    107	.switched_to		= switched_to_idle,
    108	.update_curr		= update_curr_idle,
    109};

    如上,从上面轮询调度器的顺序来看,rt进程是比cfs进程优先调度的。

    展开全文
  • Linux进程的调度优先级数字会在好几个地方出现:内核,用户,top命令。他们各自都有自己的表示法。我们用一个实际的例子来说明,下面在Linux写一个最简单的程序:编译它运行,把调度策略设置为SCHED_FIFO,优先级...
  • 本文主要介绍linux内核实时进程的调度过程。实时进程(包括SCHED_RR/SCHED_FIFO)基于优先级队列进行调度。实时进程调度类:rt_sched_class普通进程(包括SCHED_NORMAL)使用CFS调度器进行调度。普通进程调度类:...
  • 一、进程分类 ( 实时进程 | 普通进程 )、 二、Linux 内核调度策略、 1、SCHED_FIFO 调度策略、 2、SCHED_RR 调度策略、 三、实时调度实体 sched_rt_entity
  • RTlinux的介绍

    千次阅读 2021-05-12 00:47:37
    RTLinux程序运行于用户空间和内核态两个空间。RTLinux提供了应用程序接口。借助这些API函数将实时处理部分编写成内核模块,并装载到RTLinux内核中,运行于RTLinux的内核态。非实时部分的应用程序则在Linux下的用户...
  • 硬实时RTlinux系统配置4. 配置RTLinux4.1 配置Patch4.2 配置RTLinux内核4.3. 编译Rtlinux内核4.4 制作initramfs启动引导:5. 大功告成,启动运行RTlinux6. 深入探讨下RTLinux原理: RTLinux将内核变成完全抢占式所谓...
  • Linux 进程管理之进程调度与切换

    千次阅读 2022-01-27 11:14:59
    进程调度相关内核结构 我们知道,进程运行需要各种各样的系统资源,如内存、文件、打印机和最 宝贵的 CPU 等,所以说,调度的实质就是资源的分配。系统通过不同的调度算法(Scheduling Algorithm)来实现这种资源的...
  • 摘要:随着计算机技术的高速发展,实时信息处理系统已经被逐步应用于各个领域.分布式实时操作系统为这些实时信息处理系统提供了良好的运行平台,然而由于不同领域的应用对... RTLinux是一个在Linux基础上改造而来的具...
  • RTlinux编程

    2021-05-13 02:11:22
    RTlinux主要的api函数实时应用程序分为两部分,内核部分和应用部分,应用部分需要和内核部分通过FIFO进行数据交换和控制,除此之外和一般应用程序没有太多区别,内核部分比较复杂,程序以模块方式挂入内核,这部分程序的...
  • linux进程调度要点

    2021-05-10 10:39:19
    了解linux2.6的进程调度应该从以下三个方面入手:1.调度策略?2.调度时机?3.调度步骤?答:1.linux2.6的调度策略。当进程被调用时选择以下策略中的一种:SCHED_NORMAL(SCHED_OTHER):普通的分时进程SCHED_FIFO:先入...
  • Linux进程管理

    2021-05-28 22:03:06
    Linux系统中,要查看进程的信息可使用ps(process status)命令,该命令可查看记录在进程PCB中的几乎所有信息。 默认只显示在本终端上运行的进程,除非指定了-e, a, x等选项。 %CPU:进程占用CPU的时间与进程总运行...
  • (渗透测试后期)Linux进程隐藏详解

    千次阅读 2022-03-27 17:33:26
    文章目录(渗透测试后期)Linux进程隐藏详解前言Linux进程基础Linux进程侦查手段Linux进程隐藏手段一、基于用户态的进程隐藏方法1:小隐隐于/proc/pid——劫持readdir系统调用额外:加载至arm方法2:小隐隐于/proc/...
  • linux 进程优先级

    千次阅读 2018-09-16 18:42:02
    Linux 进程的优先级跟随调度算法的不断发展,其意义在不同的阶段也有着不同的含义,所以本来想从 Linux 的调度发展史写起,但是无奈那一部分的涉猎不是很深入。不管怎样,发展到最后,结果是 Linux 系统可以在同一个...
  • Linux进程调度

    2021-05-09 03:49:50
    Linux进程的主要状态如下,值状态缩写含义0TASK_RUNNINGR正在运行或可运行1TASK_INTERRUPTIBLES可中断的休眠2TASK_UNINTERRUPTIBLED不可中断的休眠4__TASK_STOPPEDT停止状态,当进程接收到SIGSTOP等signal信息8__...
  • 基于RT-Linux的数控系统进程间通信方式的研究.pdf
  • 一、进程优先级相关字段、 1、prio 字段 ( 调度优先级 )、 2、static_prio 字段 ( 静态优先级 )、 3、normal_prio 字段 ( 正常优先级 )、 4、rt_priority 字段 ( 实时优先级 )、 二、三种进程的四种优先级总结、
  • 欢迎大家一起技术交流,本博客主要是自己学习的心得体会,只为每天进步一点点!...这些函数根据现有进程的优先级分配CPU时间。这也是为什么整个方法称之为优先调度的原因。 (1)周期性调度器函数 ...
  • Linux 进程优先级查看及调整

    千次阅读 2021-05-10 01:52:12
    首先用top或者ps -l查看进程会发现有PR(PRI) NI两个字段:NI 是优先值,是用户层面的概念, PR是进程的实际优先级, 是给内核(kernel)看(用)的。一般情况下,PR=NI+20, 如果一个进程的优先级PR是20, 那么它的NI...
  • xenomai与普通linux进程之间通信——XDDP(nRT->RT).docx
  • McKenney翻译整理:土豆丝624原文链接:概述:本篇文章主要讲Linux的实时包PREEMPT_RT 是如何实现的。PREEMPT_RT 的原理PREEMPT_RT包的关键点是要使非抢占式的内核代码量尽可能的少,同时为了提供抢占性而必须修改...
  • Linux进程调度的三种策略 (1)SCHED_OTHER,分时调度策略 (2)SCHED_FIFO,实时调度策略,先到先服务 (3)SCHED_RR,实时调度策略,时间片轮转 由于相关内容比较多,本人也末必比别人讲得更清楚.
  • 【Linux】Linux进程简介及其五种状态

    万次阅读 2018-07-24 21:42:36
    由操作系统定义,并由操作系统所操控的一个特殊的数据结构实例叫做进程。它连接了用户代码,拥有代码运行所需的独立内存空间,在调度器的调度下使用分配给它的处理器时间片来运行。   进程及其私有内存空间 进程...
  • Linux进程基本概念

    2021-05-10 16:22:37
    一个标准的Linux 进程的虚拟地址空间分为 用户虚拟地址空间和内核虚拟地址空间,这其中1、所有进程共享内核虚拟地址空间----所谓的“零拷贝”等类似概念就是依赖这个特性;2、每个进程都有独立的用户虚拟地址空间---...
  • 利用RTLinux开发嵌入式应用程序    对于中国工程师来说,利用实时Linux开发嵌入式应用程序是他们面临的困难之一,本人通过这次机会以RTLinux为例,并结合最为业界关注的是RTAI与各位进行讨论,尽管这两种实现...
  • Linux进程的优先级

    2021-05-18 13:51:02
    Linux採用两种不同的优先级范围,一种是nice值。还有一种是实时优先级。1.nice值nice值得范围是-20~19,默认值是0。...Linux进程可分为普通进程和实时进程。实时进程都是一些对响应时间要求比...
  • 调整rt-linux的调度方式为实时调度: pid_t pid = getpid(); struct sched_param param; param.sched_priority = sched_get_priority_max(SCHED_FIFO); sched_setscheduler(pid, SCHED_RR, &param); pthread...
  • 摘 要:Linux作为嵌入式操作系统在嵌入式系统中应用越来越普及。...IwIP还可以使实时任务与远程实时任务或Linux用户进程通讯。根据这些特性,我们通过将Linux,IwIP和RTLinux3者合理的结合在一起,从而构

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,573
精华内容 10,629
关键字:

linux 进程rt