在内核中实现生产者消费者问题时的问题

ipiszhang

在内核中实现了一个最简单的生产者消费者模型 没有使用信号量 只用数组下标来控制同步问题 下面是代码

1. #include <linux/module.h>
   
2. #include <linux/kernel.h>
   
3. #include <linux/init.h>
   
4. 
   
5. #include <linux/kthread.h>
   
6. #include <linux/wait.h>
   
7. #include <linux/time.h>
   
8. #include <linux/delay.h>
   
9. #include <asm/param.h>
   
10. 
    
11. #define        MY_MODULE_VERSION        "v0.1"
    
12. #define        MODULE_NAME                "produdcer_consumer"
    
13. 
    
14. #define        SECOND                0.00000001
    
15. #define        BUFF_LEN        10
    
16. 
    
17. int buffer[BUFF_LEN] = {11, 12, 13, 14, 15, 16, 17, 18, 19, 0};
    
18. 
    
19. int front = 0;
    
20. int back = BUFF_LEN - 1;
    
21. int goods = 20;
    
22. 
    
23. static struct task_struct *producer_thread = NULL;
    
24. static struct task_struct *consumer_thread = NULL;
    
25. DECLARE_WAIT_QUEUE_HEAD(sleep_queue);
    
26. 
    
27. unsigned long timeout = 1;
    
28. 
    
29. static int producer(void *mode) {
    
30.         int result = 0;
    
31.         while(!kthread_should_stop()) {
    
32.                 // printk("producer\n");
    
33.                 if (back >= front && back - front < BUFF_LEN) {
    
34.                         buffer[back % BUFF_LEN] = goods;
    
35.                         back++;
    
36.                         goods++;
    
37.                         printk("producer: put goods [%d] to %d\n", goods - 1, (back - 1) % BUFF_LEN);
    
38.                 } else {
    
39.                         printk("producer: no space, sleeping\n");
    
40.                         wait_event_interruptible_timeout(sleep_queue, (back >= front && back - front < BUFF_LEN), timeout);
    
41.                 }
    
42.         }
    
43.         return result;
    
44. }
    
45. 
    
46. static int consumer(void *mode) {
    
47.         int result = 0;
    
48.         while(!kthread_should_stop()) {
    
49.                 // printk("consumer\n");
    
50.                 if (back > front) {
    
51.                         printk("consumer: get goods [%d] from %d\n", buffer[front % BUFF_LEN], front % BUFF_LEN);
    
52.                         front++;
    
53.                 } else {
    
54.                         printk("consumer: no goods, sleeping\n");
    
55.                         wait_event_interruptible_timeout(sleep_queue, (back > front), timeout * 10);
    
56.                 }
    
57.         }
    
58.         return result;
    
59. }
    
60. 
    
61. static int __init producer_consumer_init(void) {
    
62.         int result = 0;
    
63.         
    
64.         producer_thread = kthread_run(producer, NULL, "producer");
    
65.         if (!producer_thread) {
    
66.                 result = -1;
    
67.                 goto exit;
    
68.         }
    
69. 
    
70.         consumer_thread = kthread_run(consumer, NULL, "consumer");
    
71.         if (!consumer_thread) {
    
72.                 result = -1;
    
73.                 goto exit;
    
74.         }
    
75.         
    
76.         printk(KERN_INFO "%s %s initialised\n", MODULE_NAME, MY_MODULE_VERSION);
    
77. exit:
    
78.         return result;
    
79. }
    
80. 
    
81. static void __exit producer_consumer_exit(void) {
    
82.         if (producer_thread)
    
83.                 kthread_stop(producer_thread);
    
84.                
    
85.         if (consumer_thread)
    
86.                 kthread_stop(consumer_thread);
    
87.         
    
88.         printk(KERN_INFO "%s %s removed\n", MODULE_NAME, MY_MODULE_VERSION);
    
89. }
    
90. 
    
91. module_init(producer_consumer_init);
    
92. module_exit(producer_consumer_exit);
    
93. 
    
94. MODULE_LICENSE("GPL");

复制代码

首先启动生产者线程 接着启动消费者线程 缓冲区长度为10 开始时缓冲区里有前9个元素 生产者从第10个位置开始放置产品

发现一个问题 根据判断条件

1. if (back >= front && back - front < BUFF_LEN)

复制代码

只要有空间 生产者就生产并放进缓冲区

1. if (back > front)

复制代码

只要有产品 消费者就从缓冲区取出
所以执行结果应该是生产者消费者一次次交替运行
但是现在运行后发现 生产者生产10次填满缓冲区后消费者才消费 消费者将缓冲区的10个数据都取走后生产者才继续生产 而不是二者一次次交替运行

请问各位 这是为什么呢？

ShadowStar

我怀疑是由于同步的问题导致的。

把front、back、good改为atomic_t试试。

new_learner

我怀疑是由于同步的问题导致的。

把front、back、good改为atomic_t试试。
ShadowStar 发表于 2010-06-01 16:02

    他这个代码看上去逻辑好像没问题，确实有点奇怪。如果是atomic的原因，为什么正好是十次才替换？

wmmy2008

这种模型在实际中有何用处？有没具体的例子