关于内核线程的几个问题,请教

sisi8408

原帖由 Solaris12 于 2008-7-25 09:59 发表



Solaris系统的内核线程没有时间片，不属于分时调度类。

Solaris用户内核线程才有时间片的概念。

好久不见，

如果可以对kthread作nice操作，2.6.24+ scheduler就可以调度kthread, 且与preempt无关，
BTW， hrtimer and tick-sched 对2.6.26 scheduler的改进很有意思。

sisi8408

on UP,
#define MAX_SOFTIRQ_RESTART 1
and issue tcpdump
then load NIC, say 200Kpps

cat /proc/82546/status

what u get?

[ 本帖最后由 sisi8408 于 2008-7-27 11:35 编辑 ]

sisi8408

1. 
   
2. /*
   
3. * we cannot loop indefinitely here to avoid userspace starvation,
   
4. * but we also don't want to introduce a worst case 1/HZ latency
   
5. * to the pending events,
   
6. **********************************************
   
7. * so lets the scheduler to balance the softirq load for us. *
   
8. **********************************************
   
9. */
   
10. static inline void wakeup_softirqd(void)
    
11. {
    
12.         /* Interrupts are disabled: no need to stop preemption */
    
13.         struct task_struct *tsk = __get_cpu_var(ksoftirqd);
    
14. 
    
15.         if (tsk && tsk->state != TASK_RUNNING)
    
16.                 wake_up_process(tsk);
    
17. }
    

复制代码

sisi8408

1. 
   
2. /*
   
3. * in .26
   
4. *
   
5. * im not sure the following `curr` must be not kthread,
   
6. * if scheduled by cfs
   
7. */
   
8. static void check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
   
9. {
   
10.         unsigned long ideal_runtime, delta_exec;
    
11. 
    
12.         ideal_runtime = sched_slice(cfs_rq, curr);
    
13.         delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
    
14.         if (delta_exec > ideal_runtime)
    
15.                 resched_task(rq_of(cfs_rq)->curr);
    
16. }
    
17. 
    
18. static void entity_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr, int queued)
    
19. {
    
20.         /*
    
21.          * Update run-time statistics of the 'current'.
    
22.          */
    
23.         update_curr(cfs_rq);
    
24. 
    
25. #ifdef CONFIG_SCHED_HRTICK
    
26.         /*
    
27.          * queued ticks are scheduled to match the slice, so don't bother
    
28.          * validating it and just reschedule.
    
29.          */
    
30.         if (queued) {
    
31.                 resched_task(rq_of(cfs_rq)->curr);
    
32.                 return;
    
33.         }
    
34.         /*
    
35.          * don't let the period tick interfere with the hrtick preemption
    
36.          */
    
37.         if (!sched_feat(DOUBLE_TICK) &&
    
38.                 hrtimer_active(&rq_of(cfs_rq)->hrtick_timer))
    
39.                 return;
    
40. #endif
    
41. 
    
42.         if (cfs_rq->nr_running > 1 || !sched_feat(WAKEUP_PREEMPT))
    
43.                 check_preempt_tick(cfs_rq, curr);
    
44. }
    
45. 
    
46. /*
    
47. * scheduler tick hitting a task of our scheduling class:
    
48. */
    
49. static void task_tick_fair(struct rq *rq, struct task_struct *curr, int queued)
    
50. {
    
51.         struct cfs_rq *cfs_rq;
    
52.         struct sched_entity *se = &curr->se;
    
53. 
    
54.         for_each_sched_entity(se) {
    
55.                 cfs_rq = cfs_rq_of(se);
    
56.                 entity_tick(cfs_rq, se, queued);
    
57.         }
    
58. }
    
59. 
    
60. /*
    
61. * High-resolution timer tick.
    
62. * Runs from hardirq context with interrupts disabled.
    
63. */
    
64. static enum hrtimer_restart hrtick(struct hrtimer *timer)
    
65. {
    
66.         struct rq *rq = container_of(timer, struct rq, hrtick_timer);
    
67. 
    
68.         WARN_ON_ONCE(cpu_of(rq) != smp_processor_id());
    
69. 
    
70.         spin_lock(&rq->lock);
    
71.         update_rq_clock(rq);
    
72.         rq->curr->sched_class->task_tick(rq, rq->curr, 1);
    
73.         spin_unlock(&rq->lock);
    
74. 
    
75.         return HRTIMER_NORESTART;
    
76. }
    
77. 
    
78. /*
    
79. * This function gets called by the timer code, with HZ frequency.
    
80. * We call it with interrupts disabled.
    
81. *
    
82. * It also gets called by the fork code, when changing the parent's timeslices.
    
83. */
    
84. void scheduler_tick(void)
    
85. {
    
86.         int cpu = smp_processor_id();
    
87.         struct rq *rq = cpu_rq(cpu);
    
88.         struct task_struct *curr = rq->curr;
    
89. 
    
90.         sched_clock_tick();
    
91. 
    
92.         spin_lock(&rq->lock);
    
93.         update_rq_clock(rq);
    
94.         update_cpu_load(rq);
    
95.         curr->sched_class->task_tick(rq, curr, 0);
    
96.         spin_unlock(&rq->lock);
    
97. 
    
98. #ifdef CONFIG_SMP
    
99.         rq->idle_at_tick = idle_cpu(cpu);
    
100.         trigger_load_balance(rq, cpu);
     
101. #endif
     
102. }
     

复制代码