Chinaunix首页 | 论坛 | 博客
  • 博客访问: 834608
  • 博文数量: 143
  • 博客积分: 455
  • 博客等级: 一等列兵
  • 技术积分: 861
  • 用 户 组: 普通用户
  • 注册时间: 2012-08-03 00:11
文章分类

全部博文(143)

文章存档

2018年(10)

2017年(6)

2016年(28)

2015年(14)

2014年(67)

2013年(1)

2012年(17)

我的朋友

分类: LINUX

2014-01-09 14:58:38

上节中我们已经掌握了创建大量内核线程的能力,可惜线程之间还缺乏配合。要知道学习ITC(inter thread communication),和学习IPC(inter process communication)一样,不是件简单的事情。本节就暂且解释一种最简单的线程同步手段—completion。
打开include/linux/completion.h,你就会看到completion使用的全部API。这里简单介绍一下。

struct completion{  
    unsigned int done;  
    wait_queue_head_t wait;  
};  
  
void init_completion(struct completion *x);  
void wait_for_completion(struct completion *x);  
void wait_for_completion_interruptible(struct completion *x);  
void wait_for_completion_killable(struct completion *x);  
unsigned long wait_for_completion_timeout(struct completion *x,   
    unsigned long timeout);  
unsigned long wait_for_completion_interruptible_timeout(struct completion *x,   
    unsigned long timeout);  
bool try_wait_for_completion(struct completion *x);  
bool completion_done(struct completion *x);  
void complete(struct completion *x);  
void complete_all(struct completion *x); 
struct completion{
 unsigned int done;
 wait_queue_head_t wait;
};

void init_completion(struct completion *x);
void wait_for_completion(struct completion *x);
void wait_for_completion_interruptible(struct completion *x);
void wait_for_completion_killable(struct completion *x);
unsigned long wait_for_completion_timeout(struct completion *x,
 unsigned long timeout);
unsigned long wait_for_completion_interruptible_timeout(struct completion *x,
 unsigned long timeout);
bool try_wait_for_completion(struct completion *x);
bool completion_done(struct completion *x);
void complete(struct completion *x);
void complete_all(struct completion *x);

       首先是struct completion的结构,由一个计数值和一个等待队列组成。我们就大致明白,completion是类似于信号量的东西,用completion.done来表示资源是否可用,获取不到的线程会阻塞在completion.wait的等待队列上,直到其它线程释放completion。这样理解在实现上不错,但我认为completion不是与具体的资源绑定,而是单纯作为一种线程间同步的机制,它在概念上要比信号量清晰得多。以后会逐渐看到,线程间事件的同步大多靠completion,而资源临界区的保护大多靠信号量。所以说,completion是一种线程间的约会。

           init_completion初始化completion结构。初此之外,linux当然还有在定义变量时初始化的方法,都在completion.h中。

      wait_for_completion等待在completion上。如果加了interruptible,就表示线程等待可被外部发来的信号打断;如果加了killable,就表示线程只可被kill信号打断;如果加了timeout,表示等待超出一定时间会自动结束等待,timeout的单位是系统所用的时间片jiffies(多为1ms)。

      try_wait_for_completion则是非阻塞地获取completion。它相当于wait_for_completion_timeout调用中的timeout值为0。

      completion_done检查是否有线程阻塞在completion上。但这个API并不准确,它只是检查completion.done是否为0,为0则认为有线程阻塞。这个API并不会去检查实际的等待队列,所以用时要注意。

      complete唤醒阻塞在completion上的首个线程。

      complete_all唤醒阻塞在completion上的所有线程。它的实现手法很粗糙,把completion.done的值设为UINT_MAX/2,自然所有等待的线程都醒了。所以如果complete_all之后还要使用这个completion,就要把它重新初始化。

 

      好,completion介绍完毕,下面就来设计我们的模块吧。

      我们模拟5个周期性线程的运行。每个周期性线程period_thread的周期各不相同,但都以秒为单位,有各自的completion变量。period_thread每个周期运行一次,然后等待在自己的completion变量上。为了唤醒period_thread,我们使用一个watchdog_thread来模拟时钟,每隔1s watchdog_thread就会检查哪个period_thread下一周期是否到来,并用相应的completion唤醒线程。

下面就动手实现吧。

1、把上节建立的kthread子目录,复制为新的completion子目录。

2、修改hello.c,使其内容如下。

#include    
#include    
#include    
#include    
  
MODULE_LICENSE("Dual BSD/GPL");  
  
#define PERIOD_THREAD_NUM 5   
  
static int periods[PERIOD_THREAD_NUM] =   
    { 1, 2, 4, 8, 16 };  
  
static struct task_struct *period_tsks[PERIOD_THREAD_NUM];  
  
static struct task_struct watchdog_tsk;  
  
static struct completion wakeups[PERIOD_THREAD_NUM];  
  
  
static int period_thread(void *data)  
{  
    int k = (int)data;  
    int count = -1;  
  
    do{  
        printk("thread%d: period=%ds, count=%d\n", k, periods[k], ++count);  
        wait_for_completion(&wakeups[k]);  
    }while(!kthread_should_stop());  
    return count;  
}  
  
static int watchdog_thread(void *data)  
{  
    int k;  
    int count = 0;  
      
    do{  
        msleep(1000);  
        count++;  
        for(k=0; k             if (count%periods[k] == 0)  
                complete(&wakeups[k]);  
        }  
    }while(!kthread_should_stop());  
    return count;  
}  
  
static int hello_init(void)  
{  
    int k;  
  
    printk(KERN_INFO "Hello, world!\n");  
  
    for(k=0; k         init_completion(&wakeups[k]);  
    }  
  
    watchdog_tsk = kthread_run(watchdog_thread, NULL, "watchdog_thread");  
  
    if(IS_ERR(watchdog_tsk)){  
        printk(KERN_INFO "create watchdog_thread failed!\n");  
        return 1;  
    }  
  
    for(k=0; k         period_tsks[k] = kthread_run(period_thread, (void*)k, "period_thread%d", k);  
        if(IS_ERR(period_tsks[k]))  
            printk(KERN_INFO "create period_thread%d failed!\n", k);  
    }  
    return 0;  
}  
  
static void hello_exit(void)  
{  
    int k;  
    int count[5], watchdog_count;  
  
    printk(KERN_INFO "Hello, exit!\n");  
    for(k=0; k         count[k] = 0;  
        if(!IS_ERR(period_tsks[k]))  
            count[k] = kthread_stop(period_tsks[k]);  
    }  
    watchdog_count = 0;  
    if(!IS_ERR(watchdog_tsk))  
        watchdog_count = kthread_stop(watchdog_tsk);  
  
    printk("running total time: %ds\n", watchdog_count);  
    for(k=0; k         printk("thread%d: period %d, running %d times\n", k, periods[k], count[k]);  
}  
  
module_init(hello_init);  
module_exit(hello_exit); 
3、编译运行模块,步骤参照前例。为保持模块的简洁性,我们仍然使用了kthread_stop结束线程,这种方法虽然简单,但在卸载模块时等待时间太长,而且这个时间会随线程个数和周期的增长而增长。

4、使用统一的exit_flag标志来表示结束请求,hello_exit发送completion信号给所有的周期线程,最后调用kthread_stop来回收线程返回值。这样所有的周期线程都是在被唤醒后看到exit_flag,自动结束,卸载模块时间大大缩短。下面是改进过后的hello.c,之前的那个姑且叫做hello-v1.c好了。

#include    
#include    
#include    
#include    
  
MODULE_LICENSE("Dual BSD/GPL");  
  
#define PERIOD_THREAD_NUM 5   
  
static int periods[PERIOD_THREAD_NUM] =   
    { 1, 2, 4, 8, 16 };  
  
static struct task_struct *period_tsks[PERIOD_THREAD_NUM];  
  
static struct task_struct watchdog_tsk;  
  
static struct completion wakeups[PERIOD_THREAD_NUM];  
  
static int exit_flag = 0;  
  
static int period_thread(void *data)  
{  
    int k = (int)data;  
    int count = -1;  
  
    do{  
        printk("thread%d: period=%ds, count=%d\n", k, periods[k], ++count);  
        wait_for_completion(&wakeups[k]);  
    }while(!exit_flag);  
    return count;  
}  
  
static int watchdog_thread(void *data)  
{  
    int k;  
    int count = 0;  
      
    do{  
        msleep(1000);  
        count++;  
        for(k=0; k             if (count%periods[k] == 0)  
                complete(&wakeups[k]);  
        }  
    }while(!exit_flag);  
    return count;  
}  
  
static int hello_init(void)  
{  
    int k;  
  
    printk(KERN_INFO "Hello, world!\n");  
  
    for(k=0; k         init_completion(&wakeups[k]);  
    }  
  
    watchdog_tsk = kthread_run(watchdog_thread, NULL, "watchdog_thread");  
  
    if(IS_ERR(watchdog_tsk)){  
        printk(KERN_INFO "create watchdog_thread failed!\n");  
        return 1;  
    }  
  
    for(k=0; k         period_tsks[k] = kthread_run(period_thread, (void*)k, "period_thread%d", k);  
        if(IS_ERR(period_tsks[k]))  
            printk(KERN_INFO "create period_thread%d failed!\n", k);  
    }  
    return 0;  
}  
  
static void hello_exit(void)  
{  
    int k;  
    int count[5], watchdog_count;  
  
    printk(KERN_INFO "Hello, exit!\n");  
    exit_flag = 1;  
    for(k=0; k         complete_all(&wakeups[k]);  
  
    for(k=0; k         count[k] = 0;  
        if(!IS_ERR(period_tsks[k]))  
            count[k] = kthread_stop(period_tsks[k]);  
    }  
    watchdog_count = 0;  
    if(!IS_ERR(watchdog_tsk))  
        watchdog_count = kthread_stop(watchdog_tsk);  
  
    printk("running total time: %ds\n", watchdog_count);  
    for(k=0; k         printk("thread%d: period %d, running %d times\n", k, periods[k], count[k]);  
}  
  
module_init(hello_init);  
module_exit(hello_exit); 
5、编译运行改进过后的模块。可以看到模块卸载时间大大减少,不会超过1s。

经过本节,我们学会了一种内核线程间同步的机制—completion。线程们已经开始注意相互配合,以完成复杂的工作。相信它们会越来越聪明的。


附注:

completion的实现在kernel/sched.c中。这里的每个API都较短,实现也较为简单。completion背后的实现机制其实是等待队列。等待队列的实现会涉及到较多的调度问题,这里先简单略过。

本篇文章来源于 Linux公社网站()  原文链接:

阅读(827) | 评论(0) | 转发(0) |
0

上一篇:内核线程kthread

下一篇:linux应用层定时器

给主人留下些什么吧!~~