嵌入式

嵌入式 linux线程调度方式小结

2019-07-12 14:18发布

站内文章 / 嵌入式Linux
11140 0 1707
linux进程调度方法(SCHED_OTHER,SCHED_FIFO,SCHED_RR) linux进程调度方法(SCHED_OTHER,SCHED_FIFO,SCHED_RR)
linux内核的三种调度方法：
1，SCHED_OTHER 分时调度策略，
2，SCHED_FIFO实时调度策略，先到先服务
3，SCHED_RR实时调度策略，时间片轮转
linux内核的三种调度方法： 1，SCHED_OTHER 分时调度策略， 2，SCHED_FIFO实时调度策略，先到先服务 3，SCHED_RR实时调度策略，时间片轮转

实时进程将得到优先调用，实时进程根据实时优先级决定调度权值，分时进程则通过nice和counter值决定权值，nice越小，counter越大，被调度的概率越大，也就是曾经使用了cpu最少的进程将会得到优先调度。
SHCED_RR和SCHED_FIFO的不同：      当采用SHCED_RR策略的进程的时间片用完，系统将重新分配时间片，并置于就绪队列尾。放在队列尾保证了所有具有相同优先级的RR任务的调度公平。        SCHED_FIFO一旦占用cpu则一直运行。一直运行直到有更高优先级任务到达或自己放弃。     如果有相同优先级的实时进程（根据优先级计算的调度权值是一样的）已经准备好，FIFO时必须等待该进程主动放弃后才可以运行这个优先级相同的任务。而RR可以让每个任务都执行一段时间。
相同点：     RR和FIFO都只用于实时任务。     创建时优先级大于0(1-99)。     按照可抢占优先级调度算法进行。     就绪态的实时任务立即抢占非实时任务。
所有任务都采用linux分时调度策略时。 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，则会根据nice值设置该任务的时间片，同时将该任务放入就绪队列的末尾。重复步骤3。 5，当前任务由于等待资源而主动退出cpu，则其加入等待队列中。重复步骤3。
系统中既有分时调度，又有时间片轮转调度和先进先出调度
1，RR调度和FIFO调度的进程属于实时进程，以分时调度的进程是非实时进程。 2，当实时进程准备就绪后，如果当前cpu正在运行非实时进程，则实时进程立即抢占非实时进程。 3，RR进程和FIFO进程都采用实时优先级做为调度的权值标准，RR是FIFO的一个延伸。FIFO时，如果两个进程的优先级一样，则这两个优先级一样的进程具体执行哪一个是由其在队列中的未知决定的，这样导致一些不公正性(优先级是一样的，为什么要让你一直运行?),如果将两个优先级一样的任务的调度策略都设为RR,则保证了这两个任务可以循环执行，保证了公平。 应用 int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg);
来创建线程，但是如何设置线程的优先级呢？
在讨论这个问题的时候，我们先要确定当前线程使用的调度策略，posix提供了
int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy);函数来获取所
使用的调度策略，它们是：SCHED_FIFO, SCHED_RR 和 SCHED_OTHER。

我们可以使用
int sched_get_priority_max(int policy);
int sched_get_priority_min(int policy);
来获取线程线程可是设置的最大和最小的优先级值，如果调用成功就返回最大和最小的优先级值，否则返回－1。
从我现在运行的linux系统中，我使用下列程序（程序见附录）获取了对应三种调度策略中的最大和最小优先级：
policy = SCHED_OTHER
Show current configuration of priority
max_priority = 0
min_priority = 0
Show SCHED_FIFO of priority
max_priority = 99
min_priority = 1
Show SCHED_RR of priority
max_priority = 99
min_priority = 1
Show priority of current thread
priority = 0
Set thread policy
Set SCHED_FIFO policy
policy = SCHED_FIFO
Set SCHED_RR policy
policy = SCHED_RR
Restore current policy
policy = SCHED_OTHER

我们可以看到
SCHED_OTHER是不支持优先级使用的，而SCHED_FIFO和SCHED_RR支持优先级的使用，他们分别为1和99，数值越大优先级越高。 从上面的结果我们可以看出，如果程序控制线程的优先级，一般是用pthread_attr_getschedpolicy来获取系统使用的调度策略，如果是SCHED_OTHER的话，表明当前策略不支持线程优先级的使用，否则可以。当然所设定的优先级范围必须在最大和最小值之间。我们可以通过sched_get_priority_max和sched_get_priority_min来获取。

可能网友会问，是否我们可以通过int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);来设定自己所需的调度策略呢？我觉得是完全可以的（有些系统需要定义_POSIX_THREAD_PRIORITY_SCHEDULING），只要系统实现了对应的调用策略。

说了半天，我们还没有说，在系统允许使用线程优先级别的时候，如何设置优先级别呢？
int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param);
int pthread_attr_getschedparam(const pthread_attr_t *attr,  struct sched_param *param);
上面两个函数分别用于设置线程的优先级，struct sched_param的定义如下
struct sched_param
{
    int __sched_priority; //所要设定的线程优先级
};

例：创建优先级为10的线程
pthread_attr_t   attr; 
struct   sched_param   param; 
pthread_attr_init(&attr); 
pthread_attr_setschedpolicy(&attr,   SCHED_RR); 
param.sched_priority   =   10; 
pthread_attr_setschedparam(&attr,   ¶m); 
pthread_create(xxx   ,   &attr   ,   xxx   ,   xxx); 
pthread_attr_destroy(&attr);  


附：使用的测试程序：

#include
#include
#include
#include

using namespace std;

static int get_thread_policy( pthread_attr_t &attr )
{
        int policy;
        int rs = pthread_attr_getschedpolicy( &attr, &policy );
        assert( rs == 0 );
        switch ( policy )
        {
        case SCHED_FIFO:
                cout << "policy = SCHED_FIFO" << endl;
                break;

        case SCHED_RR:
                cout << "policy = SCHED_RR" << endl;
                break;

        case SCHED_OTHER:
                cout << "policy = SCHED_OTHER" << endl;
                break;

        default:
                cout << "policy = UNKNOWN" << endl;
                break;
        }

        return policy;
}

static void show_thread_priority( pthread_attr_t &attr, int policy )
{
        int priority = sched_get_priority_max( policy );
        assert( priority != -1 );
        cout << "max_priority = " << priority << endl;

        priority = sched_get_priority_min( policy );
        assert( priority != -1 );
        cout << "min_priority = " << priority << endl;
}

static int get_thread_priority( pthread_attr_t &attr )
{
        struct sched_param param;

        int rs = pthread_attr_getschedparam( &attr, ¶m );
        assert( rs == 0 );
        cout << "priority = " << param.__sched_priority << endl;

        return param.__sched_priority;
}

static void set_thread_policy( pthread_attr_t &attr,  int policy )
{
        int rs = pthread_attr_setschedpolicy( &attr, policy );
        assert( rs == 0 );
        get_thread_policy( attr );
}

int main( void )
{
        pthread_attr_t attr;
        struct sched_param sched;
        int rs;

        rs = pthread_attr_init( &attr );
        assert( rs == 0 );

        int policy = get_thread_policy( attr );

        cout << "Show current configuration of priority" << endl;
        show_thread_priority( attr, policy );

        cout << "Show SCHED_FIFO of priority" << endl;
        show_thread_priority( attr, SCHED_FIFO );

        cout << "Show SCHED_RR of priority" << endl;
        show_thread_priority( attr, SCHED_RR );

        cout << "Show priority of current thread" << endl;
        int priority = get_thread_priority( attr );

        cout << "Set thread policy" << endl;
        cout << "Set SCHED_FIFO policy" << endl;
        set_thread_policy( attr, SCHED_FIFO );
        cout << "Set SCHED_RR policy" << endl;
        set_thread_policy( attr, SCHED_RR );
        cout << "Restore current policy" << endl;
        set_thread_policy( attr, policy );


        rs = pthread_attr_destroy( &attr );
        assert( rs == 0 );

        return 0;
} 编译命令： #g++ pthread_priority3.c -o pthread_priority3 -lpthread