freebsd9.2-何时调用mini_switch函数-线程时间片用完

71v5

当statclock超时时，就会调用statclock_cnt进行相应的处理：

1. /**************************************************************************
   
2. * Statistics clock.  Updates rusage information and calls the scheduler
   
3. * to adjust priorities of the active thread.
   
4. *
   
5. * This should be called by all active processors.
   
6.            参数描述：
   
7.            cnt：statclock超时的次数。
   
8.            usermode：发生APIC TIMER中断时cpu是否处于用户态。
   
9. ***********************************/
   
10.    708        void
    
11.    709        statclock_cnt(int cnt, int usermode)
    
12.    710        {
    
13.    711                struct rusage *ru;
    
14.    712                struct vmspace *vm;
    
15.    713                struct thread *td;
    
16.    714                struct proc *p;
    
17.    715                long rss;
    
18.    716                long *cp_time;
    
19.    717        
    
20.    718                td = curthread;
    
21.    719                p = td->td_proc;
    
22.    720               
    
23. /***********************************************************************************************************
    
24. * struct pcpu数据对象的pc_cp_time成员定义如下：
    
25.                    long                pc_cp_time[CPUSTATES];        /* statclock ticks */
    
26. 
    
27.                    数组pc_cp_time的索引可以取值如下：
    
28.                    #define        CP_USER                0
    
29.                    #define        CP_NICE                1
    
30.                    #define        CP_SYS                2
    
31.                    #define        CP_INTR                3
    
32.                    #define        CP_IDLE                4
    
33.                    #define        CPUSTATES        5
    
34. 
    
35.                    #define        NZERO        0                /* default "nice" */
    
36.                    signed char        p_nice;                /* (c) Process "nice" value. */
    
37. 
    
38.                    通过722-756之间代码，可以看出什么条件下递增struct thread对象的下列成员，这些成员
    
39.                    都是对statclock超时次数进行计数：
    
40.                    td_pticks：APIC TIMER中断发生时线程运行在内核态，并且线程不是中断线程或者线程的
    
41.                               中断嵌套小于2，此时递增td_pticks。                  
    
42.                      u_int                 td_pticks;        /* (t) Statclock hits for profiling */
    
43. 
    
44.                    td_sticks：同td_pticks
    
45.                           u_int                td_sticks;        /* (t) Statclock hits in system mode. */
    
46. 
    
47.                    td_iticks：APIC TIMER中断发生时线程运行在内核态，并且线程是中断线程或者线程的
    
48.                               中断嵌套大于2，此时递增td_iticks。
    
49.                        u_int                td_iticks;        /* (t) Statclock hits in intr mode. */
    
50. 
    
51.                    td_uticks：APIC TIMER中断发生时线程运行在用户态，此时递增td_uticks。
    
52.                         u_int                td_uticks;        /* (t) Statclock hits in user mode. */
    
53.                   
    
54.                    pc_cp_time数组元素也是对statclock的超时次数进行计数，只不过使用另外一种方式
    
55.                    来描述，含义是显而易见的。
    
56. 
    
57.                    722-731：cpu处于用户态。
    
58.                    731-756：cpu处于内核态。
    
59. ************************************************************************************************/  
    
60.    721                cp_time = (long *)PCPU_PTR(cp_time);
    
61.    722                if (usermode) {
    
62.    723                        /*
    
63.    724                         * Charge the time as appropriate.
    
64.    725                         */
    
65.    726                        td->td_uticks += cnt;
    
66.    727                        if (p->p_nice > NZERO)
    
67.    728                                cp_time[CP_NICE] += cnt;
    
68.    729                        else
    
69.    730                                cp_time[CP_USER] += cnt;
    
70.    731                } else {
    
71.    732                        /*
    
72.    733                         * Came from kernel mode, so we were:
    
73.    734                         * - handling an interrupt,
    
74.    735                         * - doing syscall or trap work on behalf of the current
    
75.    736                         *   user process, or
    
76.    737                         * - spinning in the idle loop.
    
77.    738                         * Whichever it is, charge the time as appropriate.
    
78.    739                         * Note that we charge interrupts to the current process,
    
79.    740                         * regardless of whether they are ``for'' that process,
    
80.    741                         * so that we know how much of its real time was spent
    
81.    742                         * in ``non-process'' (i.e., interrupt) work.
    
82.    743                         */
    
83.    744                        if ((td->td_pflags & TDP_ITHREAD) ||
    
84.    745                            td->td_intr_nesting_level >= 2) {
    
85.    746                                td->td_iticks += cnt;
    
86.    747                                cp_time[CP_INTR] += cnt;
    
87.    748                        } else {
    
88.    749                                td->td_pticks += cnt;
    
89.    750                                td->td_sticks += cnt;
    
90.    751                                if (!TD_IS_IDLETHREAD(td))
    
91.    752                                        cp_time[CP_SYS] += cnt;
    
92.    753                                else
    
93.    754                                        cp_time[CP_IDLE] += cnt;
    
94.    755                        }
    
95.    756                }
    
96.    757        
    
97.    758               
    
98. /*********************************************************
    
99. * Update resource usage integrals and maximums.
    
100.    760-767：进程资源使用量相关处理，暂时略过。
     
101. ********************************/
     
102.    759                MPASS(p->p_vmspace != NULL);
     
103.    760                vm = p->p_vmspace;
     
104.    761                ru = &td->td_ru;
     
105.    762                ru->ru_ixrss += pgtok(vm->vm_tsize) * cnt;
     
106.    763                ru->ru_idrss += pgtok(vm->vm_dsize) * cnt;
     
107.    764                ru->ru_isrss += pgtok(vm->vm_ssize) * cnt;
     
108.    765                rss = pgtok(vmspace_resident_count(vm));
     
109.    766                if (ru->ru_maxrss < rss)
     
110.    767                        ru->ru_maxrss = rss;
     
111.    768                KTR_POINT2(KTR_SCHED, "thread", sched_tdname(td), "statclock",
     
112.    769                    "prio:%d", td->td_priority, "stathz:%d", (stathz)?stathz:hz);
     
113.    770                SDT_PROBE2(sched, , , tick, td, td->td_proc);
     
114.    771                thread_lock_flags(td, MTX_QUIET);
     
115. /******************************************************
     
116. * 772-773: 重点
     
117.     调度程序相关的sched_clock函数。
     
118. **************************/
     
119.    772                for ( ; cnt > 0; cnt--)
     
120.    773                        sched_clock(td);
     
121.    774                thread_unlock(td);
     
122.    775        #ifdef HWPMC_HOOKS
     
123.    776                if (td->td_intr_frame != NULL)
     
124.    777                        PMC_SOFT_CALL_TF( , , clock, stat, td->td_intr_frame);
     
125.    778        #endif
     
126.    779        }

复制代码

[ULE调度程序的sched_clock函数]：

1.   2174        /*
   
2.   2175         * Handle a stathz tick.  This is really only relevant for timeshare
   
3.   2176         * threads.
   
4.   2177         */
   
5.   2178        void
   
6.   2179        sched_clock(struct thread *td)
   
7.   2180        {
   
8.   2181                struct tdq *tdq;
   
9.   2182                struct td_sched *ts;
   
10.   2183                /* 2185：tdq指向当前cpu对应的struct tdq对象 */
    
11.   2184                THREAD_LOCK_ASSERT(td, MA_OWNED);
    
12.   2185                tdq = TDQ_SELF();
    
13.   2186        #ifdef SMP
    
14.   2187               
    
15.   2188
    
16. /**********************************************************************************************
    
17. * We run the long term load balancer infrequently on the first cpu.
    
18. 
    
19.                    static struct tdq       *balance_tdq;
    
20.                    static int balance_ticks;
    
21. 
    
22.                    2190-2193：
    
23.                    在ULE调度程序初始化阶段，BSP会将balance_tdq设置为BSP对应的struct tdq
    
24.                    数据对象的地址。
    
25.                   
    
26.                    balance_ticks为调用sched_balance函数在系统中cpu的运行队列间迁移线程
    
27.                    的周期，在ULE调度程序初始化阶段设置，具体值是多少应该没什么意义：
    
28.                    balance_interval默认值为128.
    
29.                    balance_ticks = max(balance_interval / 2, 1);
    
30.                    balance_ticks += random() % balance_interval;
    
31. 
    
32.                    当balance_ticks为零0时，函数sched_balance就要保持系统中cpu运行队列
    
33.                    间的平衡。
    
34. *******************************************/
    
35.   2189                 
    
36.   2190                if (balance_tdq == tdq) {
    
37.   2191                        if (balance_ticks && --balance_ticks == 0)
    
38.   2192                                sched_balance();
    
39.   2193                }
    
40.   2194        #endif
    
41.   2195                /*
    
42.   2196                 * Save the old switch count so we have a record of the last ticks
    
43.   2197                 * activity.   Initialize the new switch count based on our load.
    
44.   2198                 * If there is some activity seed it to reflect that.
    
45.   2199                 */
    
46.   2200                tdq->tdq_oldswitchcnt = tdq->tdq_switchcnt;
    
47.   2201                tdq->tdq_switchcnt = tdq->tdq_load;
    
48. /**************************************************************************
    
49. * Advance the insert index once for each tick to ensure that all
    
50. * threads get a chance to run.
    
51.    2206-2210：防止时间片轮转的线程发生饿死现象。
    
52. *************************/
    
53.   2205                 */
    
54.   2206                if (tdq->tdq_idx == tdq->tdq_ridx) {
    
55.   2207                        tdq->tdq_idx = (tdq->tdq_idx + 1) % RQ_NQS;
    
56.   2208                        if (TAILQ_EMPTY(&tdq->tdq_timeshare.rq_queues[tdq->tdq_ridx]))
    
57.   2209                                tdq->tdq_ridx = tdq->tdq_idx;
    
58.   2210                }
    
59. /*****************************************************************
    
60. * 2211：ts指向和td相关联的struct td_sched数据对象。
    
61.    2212：函数sched_pctcpu_updat更新struct td_sched数据对象中的
    
62.           相关成员。
    
63. *********************************/
    
64.   2211                ts = td->td_sched;
    
65.   2212                sched_pctcpu_update(ts, 1);
    
66. /******************************************************
    
67. * #define PRI_FIFO_BIT            8
    
68.    如果线程td的调度类为PRI_FIFO_BIT，这里就直接返回。
    
69. *****************************/
    
70.   2213                if (td->td_pri_class & PRI_FIFO_BIT)
    
71.   2214                        return;
    
72. /**********************************************************************
    
73. * 2215-2223：
    
74.    #define PRI_TIMESHARE  3  Time sharing process.
    
75.    如果线程td的调度类为时间片轮转，此时就要进行相应的处理：
    
76.    2220：给线程运行时间增加一个tickincr，ULE调度程序源码中
    
77.          对该变量的描述如下：
    
78.          tickincr:Converts a stathz tick into a hz domain scaled by
    
79.                   the shift factor.  Without the shift the error rate
    
80.                   due to rounding would be unacceptably high.
    
81. 
    
82.    2221：sched_interact_update函数调整td的睡眠时间和运行时间。
    
83.    
    
84.    2222：sched_priority函数调整struct thread对象的td_user_pri，
    
85.          td_base_user_pri两个成员。
    
86. *********************************************/
    
87.   2215                if (PRI_BASE(td->td_pri_class) == PRI_TIMESHARE) {
    
88.   2216                        /*
    
89.   2217                         * We used a tick; charge it to the thread so
    
90.   2218                         * that we can compute our interactivity.
    
91.   2219                         */
    
92.   2220                        td->td_sched->ts_runtime += tickincr;
    
93.   2221                        sched_interact_update(td);
    
94.   2222                        sched_priority(td);
    
95.   2223                }
    
96.   2224        
    
97. /************************************************************************
    
98. * Force a context switch if the current thread has used up a full
    
99. * time slice (default is 100ms).
    
100. 
     
101.    #define        TDF_NEEDRESCHED        0x00010000  Thread needs to yield.
     
102.    #define TDF_SLICEEND    TDF_SCHED2     Thread time slice is over.
     
103. 
     
104.    sched_slice：
     
105.    ULE调度程序源码中对该变量的描述为：Runtime of each thread before
     
106.    rescheduling，默认值为12，可见sched_slice为每个线程的时间片，
     
107.    因为statclock的周期为1/128秒，在使用默认时间片的情况下，一个线程
     
108.    用完其时间片的大概时间为（1/128） * 12，这个结果为0.09秒，约为0.1秒，
     
109.    即100毫秒。
     
110.                   
     
111.    2229-2231：
     
112.    如果线程td不是idle线程，并且线程td的时间片用完，此时：
     
113.    2230：重新设置线程td的时间片。
     
114.    2231：给线程td设置TDF_NEEDRESCHED和TDF_SLICEEND标志。
     
115.          在中断返回时，会检查线程td是否设置了TDF_NEEDRESCHED标志，
     
116.          如果设置，就调用mini_switch函数。            
     
117. *******************************/
     
118.   2229                if (!TD_IS_IDLETHREAD(td) && --ts->ts_slice <= 0) {
     
119.   2230                        ts->ts_slice = sched_slice;
     
120.   2231                        td->td_flags |= TDF_NEEDRESCHED | TDF_SLICEEND;
     
121.   2232                }
     
122.   2233        }

复制代码