• 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. 

    2.     atomic_long_t data;       /*工作处理函数func的参数*/  
      3. 

    3. #define WORK_STRUCT_PENDING 0        /* T if work item pending execution */  
      4. 

    4. #define WORK_STRUCT_STATIC 1        /* static initializer (debugobjects) */  
      5. 

    5. #define WORK_STRUCT_FLAG_MASK (3UL)  
      6. 

    6. #define WORK_STRUCT_WQ_DATA_MASK (~WORK_STRUCT_FLAG_MASK)  
      7. 

    7.     struct list_head entry;        /*连接工作的指针*/  
      8. 

    8.     work_func_t func;              /*工作处理函数*/  
      9. 

    9. #ifdef CONFIG_LOCKDEP  
      10. 

    10.     struct lockdep_map lockdep_map;  
      11. 

    11. #endif  
      12. 

    12. };  
      13. 


    


          这些工作以队列结构组织成工作队列（workqueue），其数据结构为workqueue_struct:
    

    

    

    [cpp] view plaincopy

     
    


    


    

      

    1. struct workqueue_struct {  
      2. 

    2.  struct cpu_workqueue_struct *cpu_wq;  
      3. 

    3.  struct list_head list;  
      4. 

    4.  const char *name;   /*workqueue name*/  
      5. 

    5.  int singlethread;   /*是不是单线程 - 单线程我们首选第一个CPU -0表示采用默认的工作者线程event*/  
      6. 

    6.  int freezeable;  /* Freeze threads during suspend */  
      7. 

    7.  int rt;  
      8. 

    8. };   
      9. 


    


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

    

    

    [cpp] view plaincopy

     
    


    


    

      

    1. truct cpu_workqueue_struct {  
      2. 

    2.  spinlock_t lock;/*因为工作者线程需要频繁的处理连接到其上的工作，所以需要枷锁保护*/  
      3. 

    3.  struct list_head worklist;  
      4. 

    4.  wait_queue_head_t more_work;  
      5. 

    5.  struct work_struct *current_work; /*当前的work*/  
      6. 

    6.  struct workqueue_struct *wq;   /*所属的workqueue*/  
      7. 

    7.  struct task_struct *thread; /*任务的上下文*/  
      8. 

    8. } ____cacheline_aligned;  
      9. 


    

           在该结构主要维护了一个任务队列，以及内核线程需要睡眠的等待队列，另外还维护了一个任务上下文，即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. 

    2. #include <linux/init.h>  
      3. 

    3. #include <linux/workqueue.h>  
      4. 

    4.   
      5. 

    5. static struct workqueue_struct *queue=NULL;  
      6. 

    6. static struct work_struct   work;  
      7. 

    7.   
      8. 

    8. staticvoid work_handler(struct work_struct *data)  
      9. 

    9. {  
      10. 

    10.        printk(KERN_ALERT"work handler function.
");  
      11. 

    11. }  
      12. 

    12.   
      13. 

    13. static int __init test_init(void)  
      14. 

    14. {  
      15. 

    15.       queue=create_singlethread_workqueue("hello world");/*创建一个单线程的工作队列*/  
      16. 

    16.       if (!queue)  
      17. 

    17.             goto err;  
      18. 

    18.   
      19. 

    19.        INIT_WORK(&work,work_handler);  
      20. 

    20.        schedule_work(&work);  
      21. 

    21.   
      22. 

    22.       return0;  
      23. 

    23. err:  
      24. 

    24.       return-1;  
      25. 

    25. }  
      26. 

    26.   
      27. 

    27. static   void __exit test_exit(void)  
      28. 

    28. {  
      29. 

    29.        destroy_workqueue(queue);  
      30. 

    30. }  
      31. 

    31. MODULE_LICENSE("GPL");  
      32. 

    32. module_init(test_init);  
      33. 

    33. module_exit(test_exit);  
      34. 


    


    



































    

    


    

    

    序号
    

    		

    

    接口函数
    

    		

    

    说明
    

    		


    

    

    

    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/
    

    
    
          
    • 

          
  • 

            相关阅读:
    
            
              寒假学习第一天
                
    课堂测试
                
    第十六周总结
                
    第十五周总结
                
    计算最长单词链
                
    第十四周总结
                
    人月神话阅读笔记03
                
    人月神话阅读笔记02
                
    第十五周学习进度
                
    冲刺第二十天
                
                    
          
    • 
          
  • 
            原文地址：https://www.cnblogs.com/sky-heaven/p/5847520.html
          
    • 

        

      



      
      

        

        

      

    

  


  

  
Copyright © 2020-2023 
  润新知