Linux workqueue疑问【转】

转自:http://blog.csdn.net/angle_birds/article/details/9387365

各位大神,你们好。我在使用workqueue的过程中遇到一个问题。
项目采用uClinux系统,VoIP相关的。
现有两个驱动,一个是负责数据传输的,还有一个是负责打电话的。这两个驱动里分别使用了一个workqueue。在数据传输量很大时,负责数据传输的workqueue非常耗费资源,CPU占用能达到60-70%。这时候,我打电话,也就是让负责打电话的workqueue工作,但是此时打电话的workqueue执行会出现延时(这个打电话的workqueue对时间很敏感),打电话就不正常了。没有数据传输或者数据量很小时,一切正常。
我尝试着将打电话的代码全部放到中断程序里做(这样任何人都不能打断他,除非更高级别的中断),然而打电话调用的API会出现睡眠的情况,内核会崩溃(中断程序中不能睡眠)。

我现在想知道workqueue有没有优先级的概念?有的话我可以把打电话的workqueue优先级设置为高。这样不管数据传输那边有多忙,电话总是能抢到CPU啊!
我查了网上的资料,workqueue其实就是一个内核线程,既然是线程,应该有优先级的概念啊。由于我没有内核编程的经验,还请有经验的大侠给予指导!

小弟先谢谢了!

峰吹过地无痕|五级
workqueue是一个内核线程,不过队列中的任务并不是线程.
中断肯定不行啊,长时间中断肯定会崩溃啊。
你可以flush workqueue来试试。
我还不太了解你做的这个。
追问
flush workqueue已经试验了,不行。我在数据传输的workqueue里flush 打电话的workqueue,最后发现打电话还是不能立即占用CPU。
我了解到采用workqueue的话程序的实时性不好,不知道有没有其他的方法?比如:像tasklet能立即处理,又能像workqueue能够睡眠?
回答
…… 那你到底让它什么时候立即处理什么时候睡眠啊。系统怎么知道你的需求啊,你的确切的告诉系统啊

评论|0

2012-05-12 16:01热心网友

为什么不用中断线程去做,把打电话workqueue里的东西放到中断线程中去,可以用request_threaded_irq注册

追问
我使用的是uclinux,2.6.14版本,还没有这个函数啊。这个函数什么时候加的?
request_threaded_irq

1. 什么是workqueue
       Linux中的Workqueue机制就是为了简化内核线程的创建。通过调用workqueue的接口就能创建内核线程。并且可以根据当前系统CPU的个数创建线程的数量,使得线程处理的事务能够并行化。workqueue是内核中实现简单而有效的机制,他显然简化了内核daemon的创建,方便了用户的编程.

工作队列(workqueue)是另外一种将工作推后执行的形式.工作队列可以把工作推后,交由一个内核线程去执行,也就是说,这个下半部分可以在进程上下文中执行。最重要的就是工作队列允许被重新调度甚至是睡眠。

2. 数据结构
     我们把推后执行的任务叫做工作(work),描述它的数据结构为work_struct:

[cpp] view plaincopy

  1. struct work_struct {
  2. atomic_long_t data;       /*工作处理函数func的参数*/
  3. #define WORK_STRUCT_PENDING 0        /* T if work item pending execution */
  4. #define WORK_STRUCT_STATIC 1        /* static initializer (debugobjects) */
  5. #define WORK_STRUCT_FLAG_MASK (3UL)
  6. #define WORK_STRUCT_WQ_DATA_MASK (~WORK_STRUCT_FLAG_MASK)
  7. struct list_head entry;        /*连接工作的指针*/
  8. work_func_t func;              /*工作处理函数*/
  9. #ifdef CONFIG_LOCKDEP
  10. struct lockdep_map lockdep_map;
  11. #endif
  12. };

这些工作以队列结构组织成工作队列(workqueue),其数据结构为workqueue_struct:

[cpp] view plaincopy

  1. struct workqueue_struct {
  2. struct cpu_workqueue_struct *cpu_wq;
  3. struct list_head list;
  4. const char *name;   /*workqueue name*/
  5. int singlethread;   /*是不是单线程 - 单线程我们首选第一个CPU -0表示采用默认的工作者线程event*/
  6. int freezeable;  /* Freeze threads during suspend */
  7. int rt;
  8. };

如果是多线程,Linux根据当前系统CPU的个数创建cpu_workqueue_struct 其结构体就是:

[cpp] view plaincopy

  1. truct cpu_workqueue_struct {
  2. spinlock_t lock;/*因为工作者线程需要频繁的处理连接到其上的工作,所以需要枷锁保护*/
  3. struct list_head worklist;
  4. wait_queue_head_t more_work;
  5. struct work_struct *current_work; /*当前的work*/
  6. struct workqueue_struct *wq;   /*所属的workqueue*/
  7. struct task_struct *thread; /*任务的上下文*/
  8. } ____cacheline_aligned;

在该结构主要维护了一个任务队列,以及内核线程需要睡眠的等待队列,另外还维护了一个任务上下文,即task_struct。
       三者之间的关系如下:

3. 创建工作
3.1 创建工作queue
a. create_singlethread_workqueue(name)
        该函数的实现机制如下图所示,函数返回一个类型为struct workqueue_struct的指针变量,该指针变量所指向的内存地址在函数内部调用kzalloc动态生成。所以driver在不再使用该work queue的情况下调用:

void destroy_workqueue(struct workqueue_struct *wq)来释放此处的内存地址。

图中的cwq是一per-CPU类型的地址空间。对于create_singlethread_workqueue而言,即使是对于多CPU系统,内核也只负责创建一个worker_thread内核进程。该内核进程被创建之后,会先定义一个图中的wait节点,然后在一循环体中检查cwq中的worklist,如果该队列为空,那么就会把wait节点加入到cwq中的more_work中,然后休眠在该等待队列中。

Driver调用queue_work(struct workqueue_struct *wq, struct work_struct *work)向wq中加入工作节点。work会依次加在cwq->worklist所指向的链表中。queue_work向cwq->worklist中加入一个work节点,同时会调用wake_up来唤醒休眠在cwq->more_work上的worker_thread进程。wake_up会先调用wait节点上的autoremove_wake_function函数,然后将wait节点从cwq->more_work中移走。

worker_thread再次被调度,开始处理cwq->worklist中的所有work节点...当所有work节点处理完毕,worker_thread重新将wait节点加入到cwq->more_work,然后再次休眠在该等待队列中直到Driver调用queue_work...

b. create_workqueue

相对于create_singlethread_workqueue, create_workqueue同样会分配一个wq的工作队列,但是不同之处在于,对于多CPU系统而言,对每一个CPU,都会为之创建一个per-CPU的cwq结构,对应每一个cwq,都会生成一个新的worker_thread进程。但是当用queue_work向cwq上提交work节点时,是哪个CPU调用该函数,那么便向该CPU对应的cwq上的worklist上增加work节点。

c.小结
       当用户调用workqueue的初始化接口create_workqueue或者create_singlethread_workqueue对workqueue队列进行初始化时,内核就开始为用户分配一个workqueue对象,并且将其链到一个全局的workqueue队列中。然后Linux根据当前CPU的情况,为workqueue对象分配与CPU个数相同的cpu_workqueue_struct对象,每个cpu_workqueue_struct对象都会存在一条任务队列。紧接着,Linux为每个cpu_workqueue_struct对象分配一个内核thread,即内核daemon去处理每个队列中的任务。至此,用户调用初始化接口将workqueue初始化完毕,返回workqueue的指针。

workqueue初始化完毕之后,将任务运行的上下文环境构建起来了,但是具体还没有可执行的任务,所以,需要定义具体的work_struct对象。然后将work_struct加入到任务队列中,Linux会唤醒daemon去处理任务。

上述描述的workqueue内核实现原理可以描述如下:

3.2  创建工作
       要使用工作队列,首先要做的是创建一些需要推后完成的工作。可以通过DECLARE_WORK在编译时静态地建该结构:
       DECLARE_WORK(name,void (*func) (void *), void *data);
      这样就会静态地创建一个名为name,待执行函数为func,参数为data的work_struct结构。
      同样,也可以在运行时通过指针创建一个工作:
      INIT_WORK(structwork_struct *work, woid(*func) (void *), void *data);

4. 调度
a. schedule_work

在大多数情况下, 并不需要自己建立工作队列,而是只定义工作, 将工作结构挂接到内核预定义的事件工作队列中调度, 在kernel/workqueue.c中定义了一个静态全局量的工作队列static struct workqueue_struct *keventd_wq;默认的工作者线程叫做events/n,这里n是处理器的编号,每个处理器对应一个线程。比如,单处理器的系统只有events/0这样一个线程。而双处理器的系统就会多一个events/1线程。
       调度工作结构, 将工作结构添加到全局的事件工作队列keventd_wq,调用了queue_work通用模块。对外屏蔽了keventd_wq的接口,用户无需知道此参数,相当于使用了默认参数。keventd_wq由内核自己维护,创建,销毁。这样work马上就会被调度,一旦其所在的处理器上的工作者线程被唤醒,它就会被执行。

b. schedule_delayed_work(&work,delay);
      有时候并不希望工作马上就被执行,而是希望它经过一段延迟以后再执行。在这种情况下,同时也可以利用timer来进行延时调度,到期后才由默认的定时器回调函数进行工作注册。延迟delay后,被定时器唤醒,将work添加到工作队列wq中。

工作队列是没有优先级的,基本按照FIFO的方式进行处理。

 5. 示例

[cpp] view plaincopy

  1. #include <linux/module.h>
  2. #include <linux/init.h>
  3. #include <linux/workqueue.h>
  4. static struct workqueue_struct *queue=NULL;
  5. static struct work_struct   work;
  6. staticvoid work_handler(struct work_struct *data)
  7. {
  8. printk(KERN_ALERT"work handler function.\n");
  9. }
  10. static int __init test_init(void)
  11. {
  12. queue=create_singlethread_workqueue("hello world");/*创建一个单线程的工作队列*/
  13. if (!queue)
  14. goto err;
  15. INIT_WORK(&work,work_handler);
  16. schedule_work(&work);
  17. return0;
  18. err:
  19. return-1;
  20. }
  21. static   void __exit test_exit(void)
  22. {
  23. destroy_workqueue(queue);
  24. }
  25. MODULE_LICENSE("GPL");
  26. module_init(test_init);
  27. module_exit(test_exit);

序号

接口函数

说明

1

create_workqueue

用于创建一个workqueue队列,为系统中的每个CPU都创建一个内核线程。输入参数:

@name:workqueue的名称

2

create_singlethread_workqueue

用于创建workqueue,只创建一个内核线程。输入参数:

@name:workqueue名称

3

destroy_workqueue

释放workqueue队列。输入参数:

@ workqueue_struct:需要释放的workqueue队列指针

4

schedule_work

调度执行一个具体的任务,执行的任务将会被挂入Linux系统提供的workqueue——keventd_wq输入参数:

@ work_struct:具体任务对象指针

5

schedule_delayed_work

延迟一定时间去执行一个具体的任务,功能与schedule_work类似,多了一个延迟时间,输入参数:

@work_struct:具体任务对象指针

@delay:延迟时间

6

queue_work

调度执行一个指定workqueue中的任务。输入参数:

@ workqueue_struct:指定的workqueue指针

@work_struct:具体任务对象指针

7

queue_delayed_work

延迟调度执行一个指定workqueue中的任务,功能与queue_work类似,输入参数多了一个delay。

转自:http://bgutech.blog.163.com/blog/static/18261124320116181119889/

时间: 2024-10-14 02:50:33

Linux workqueue疑问【转】的相关文章

[内核]Linux workqueue

转自:http://blog.chinaunix.net/uid-24148050-id-296982.html 一.workqueue简介 workqueue与tasklet类似,都是允许内核代码请求某个函数在将来的时间被调用(抄<ldd3>上的)每个workqueue就是一个内核进程. workqueue与tasklet的区别: tasklet是通过软中断实现的,在软中断上下文中运行,tasklet代码必须是原子的. 而workqueue是通过内核进程实现的,就没有上述限制的,而且工作队列

Linux workqueue工作原理 【转】

转自:http://blog.chinaunix.net/uid-21977330-id-3754719.html 转自:http://bgutech.blog.163.com/blog/static/18261124320116181119889/1. 什么是workqueue       Linux中的Workqueue机制就是为了简化内核线程的创建.通过调用workqueue的接口就能创建内核线程.并且可以根据当前系统CPU的个 数创建线程的数量,使得线程处理的事务能够并行化.workqu

Linux tasklet 和workqueue学习

中断服务程序一般都是在中断请求关闭的条件下执行的,以避免嵌套而使中断控制复杂化.但是,中断是一个随机事件,它随时会到来,如果关中断的时间太长,CPU就不能及时响应其他的中断请求,从而造成中断的丢失.因此,Linux内核的目标就是尽可能快的处理完中断请求,尽其所能把更多的处理向后推迟.例如,假设一个数据块已经达到了网线,当中断控制器接受到这个中断请求信号时,Linux内核只是简单地标志数据到来了,然后让处理器恢复到它以前运行的状态,其余的处理稍后再进行(如把数据移入一个缓冲区,接受数据的进程就可以

内核工作队列workqueue

LDD3: 工作队列是, 表面上看, 类似于 taskets; 它们允许内核代码来请求在将来某个时间调用一个函数. 但是, 有几个显著的不同在这 2 个之间, 包括: (1) tasklet 在软件中断上下文中运行的结果是所有的 tasklet 代码必须是原子的. 相反, 工作队列函数在一个特殊内核进程上下文运行; 结果, 它们有更多的灵活性. 特别地, 工作队列函数能够睡眠. (2) tasklet 常常在它们最初被提交的处理器上运行. 工作队列以相同地方式工作, 缺省地. (3) 内核代码可

《Linux Device Drivers》 第七章 时间、延时及延缓操作——note

度量时间差 内核通过定时器中断来跟踪时间流 时钟中断由系统定时硬件以周期性的间隔产生,这个间隔由内核根据HZ的值设定,在常见的x86 PC平台上,默认定义为1000 <linux/param.h> <linux/timex.h> jiffies_64 unsigned long jiffies 使用jiffies计数器 <linux/jiffies.h> int time_after(unsigned long a, unsigned long b); int time

linux驱动之LCD

LCD程序步骤:1. 分配一个fb_info 2. 设置 3. 硬件相关的操作4. 注册 register_framebuffer 5.入口函数 6.出口函数 #include <linux/string.h>#include <linux/mm.h>#include <linux/slab.h>#include <linux/delay.h>#include <linux/fb.h>#include <linux/init.h>#i

android应用程序访问linux驱动第一步:实现并测试Linux驱动

一直都想亲自做一次使用android应用程序访问Linux内核驱动的尝试,但总是没能做到.最近抽出时间,下决心重新尝试一次.尝试的开始当然是先写一个Linux内核驱动了. 我希望写一个简单测驱动程序,实现写一个字符串进去,然后再把它读出来的功能.驱动中会创建dev/hello设备节点和/sys/class/hello/hello/val 设备节点,没有实现proc/下的对应的设备节点./sys/class/hello/hello/val 主要用于快速测试,而dev/hello则主要用于供上层应用

Linux Bluetooth内核分析之HCI部分

关于HCI规范相关内容,请看<Bluetooth HCI介绍> 首先我们要了解,在Linux上实现的是HCI的Host部分 1. 相关数据结构 1.1 hci_dev 在Linux中hci_dev用来表示一个HCI Host(对应于一个Control) 成员 作用 char name[8] 蓝牙名称 __u8 bus HCI总线类型,有HCI_USB,HCI_PCCARD,HCI_UART,HCI_PCI等 __u8 dev_type HCI Controller类型,有HCI_BREDR,H

浅谈linux的LCD驱动

一.硬件基础 1.硬件框图 2.LCD控制器 了解硬件最直接的办法就是看手册,在这里我只会简单介绍下LCD的硬件.具体的我会在下面结合程序讲解. a.REGBANK是LCD控制器的寄存器,含17个寄存器以及一块256*16的调色内存,用来设置各项参数. b.LCDCDMA是LCD控制器专用的DMA信道. c.TIMEGEN和LPC3600负责产生LCD屏所需要的控制时序. d.VIDPRCS需要与LCDCDMA中的数组合成特定的格式,然后从VD[23:0]发送给LCD屏幕. 3.时序理解 二.驱