Root/
Source at commit ec7cab4cbb721bff91ec924ec691efd8daf36579 created 12 years 8 months ago. By Maarten ter Huurne, MIPS: JZ4740: A320: Updated quickstart documentation. | |
---|---|
1 | |
2 | Concurrency Managed Workqueue (cmwq) |
3 | |
4 | September, 2010 Tejun Heo <tj@kernel.org> |
5 | Florian Mickler <florian@mickler.org> |
6 | |
7 | CONTENTS |
8 | |
9 | 1. Introduction |
10 | 2. Why cmwq? |
11 | 3. The Design |
12 | 4. Application Programming Interface (API) |
13 | 5. Example Execution Scenarios |
14 | 6. Guidelines |
15 | 7. Debugging |
16 | |
17 | |
18 | 1. Introduction |
19 | |
20 | There are many cases where an asynchronous process execution context |
21 | is needed and the workqueue (wq) API is the most commonly used |
22 | mechanism for such cases. |
23 | |
24 | When such an asynchronous execution context is needed, a work item |
25 | describing which function to execute is put on a queue. An |
26 | independent thread serves as the asynchronous execution context. The |
27 | queue is called workqueue and the thread is called worker. |
28 | |
29 | While there are work items on the workqueue the worker executes the |
30 | functions associated with the work items one after the other. When |
31 | there is no work item left on the workqueue the worker becomes idle. |
32 | When a new work item gets queued, the worker begins executing again. |
33 | |
34 | |
35 | 2. Why cmwq? |
36 | |
37 | In the original wq implementation, a multi threaded (MT) wq had one |
38 | worker thread per CPU and a single threaded (ST) wq had one worker |
39 | thread system-wide. A single MT wq needed to keep around the same |
40 | number of workers as the number of CPUs. The kernel grew a lot of MT |
41 | wq users over the years and with the number of CPU cores continuously |
42 | rising, some systems saturated the default 32k PID space just booting |
43 | up. |
44 | |
45 | Although MT wq wasted a lot of resource, the level of concurrency |
46 | provided was unsatisfactory. The limitation was common to both ST and |
47 | MT wq albeit less severe on MT. Each wq maintained its own separate |
48 | worker pool. A MT wq could provide only one execution context per CPU |
49 | while a ST wq one for the whole system. Work items had to compete for |
50 | those very limited execution contexts leading to various problems |
51 | including proneness to deadlocks around the single execution context. |
52 | |
53 | The tension between the provided level of concurrency and resource |
54 | usage also forced its users to make unnecessary tradeoffs like libata |
55 | choosing to use ST wq for polling PIOs and accepting an unnecessary |
56 | limitation that no two polling PIOs can progress at the same time. As |
57 | MT wq don't provide much better concurrency, users which require |
58 | higher level of concurrency, like async or fscache, had to implement |
59 | their own thread pool. |
60 | |
61 | Concurrency Managed Workqueue (cmwq) is a reimplementation of wq with |
62 | focus on the following goals. |
63 | |
64 | * Maintain compatibility with the original workqueue API. |
65 | |
66 | * Use per-CPU unified worker pools shared by all wq to provide |
67 | flexible level of concurrency on demand without wasting a lot of |
68 | resource. |
69 | |
70 | * Automatically regulate worker pool and level of concurrency so that |
71 | the API users don't need to worry about such details. |
72 | |
73 | |
74 | 3. The Design |
75 | |
76 | In order to ease the asynchronous execution of functions a new |
77 | abstraction, the work item, is introduced. |
78 | |
79 | A work item is a simple struct that holds a pointer to the function |
80 | that is to be executed asynchronously. Whenever a driver or subsystem |
81 | wants a function to be executed asynchronously it has to set up a work |
82 | item pointing to that function and queue that work item on a |
83 | workqueue. |
84 | |
85 | Special purpose threads, called worker threads, execute the functions |
86 | off of the queue, one after the other. If no work is queued, the |
87 | worker threads become idle. These worker threads are managed in so |
88 | called thread-pools. |
89 | |
90 | The cmwq design differentiates between the user-facing workqueues that |
91 | subsystems and drivers queue work items on and the backend mechanism |
92 | which manages thread-pool and processes the queued work items. |
93 | |
94 | The backend is called gcwq. There is one gcwq for each possible CPU |
95 | and one gcwq to serve work items queued on unbound workqueues. |
96 | |
97 | Subsystems and drivers can create and queue work items through special |
98 | workqueue API functions as they see fit. They can influence some |
99 | aspects of the way the work items are executed by setting flags on the |
100 | workqueue they are putting the work item on. These flags include |
101 | things like CPU locality, reentrancy, concurrency limits and more. To |
102 | get a detailed overview refer to the API description of |
103 | alloc_workqueue() below. |
104 | |
105 | When a work item is queued to a workqueue, the target gcwq is |
106 | determined according to the queue parameters and workqueue attributes |
107 | and appended on the shared worklist of the gcwq. For example, unless |
108 | specifically overridden, a work item of a bound workqueue will be |
109 | queued on the worklist of exactly that gcwq that is associated to the |
110 | CPU the issuer is running on. |
111 | |
112 | For any worker pool implementation, managing the concurrency level |
113 | (how many execution contexts are active) is an important issue. cmwq |
114 | tries to keep the concurrency at a minimal but sufficient level. |
115 | Minimal to save resources and sufficient in that the system is used at |
116 | its full capacity. |
117 | |
118 | Each gcwq bound to an actual CPU implements concurrency management by |
119 | hooking into the scheduler. The gcwq is notified whenever an active |
120 | worker wakes up or sleeps and keeps track of the number of the |
121 | currently runnable workers. Generally, work items are not expected to |
122 | hog a CPU and consume many cycles. That means maintaining just enough |
123 | concurrency to prevent work processing from stalling should be |
124 | optimal. As long as there are one or more runnable workers on the |
125 | CPU, the gcwq doesn't start execution of a new work, but, when the |
126 | last running worker goes to sleep, it immediately schedules a new |
127 | worker so that the CPU doesn't sit idle while there are pending work |
128 | items. This allows using a minimal number of workers without losing |
129 | execution bandwidth. |
130 | |
131 | Keeping idle workers around doesn't cost other than the memory space |
132 | for kthreads, so cmwq holds onto idle ones for a while before killing |
133 | them. |
134 | |
135 | For an unbound wq, the above concurrency management doesn't apply and |
136 | the gcwq for the pseudo unbound CPU tries to start executing all work |
137 | items as soon as possible. The responsibility of regulating |
138 | concurrency level is on the users. There is also a flag to mark a |
139 | bound wq to ignore the concurrency management. Please refer to the |
140 | API section for details. |
141 | |
142 | Forward progress guarantee relies on that workers can be created when |
143 | more execution contexts are necessary, which in turn is guaranteed |
144 | through the use of rescue workers. All work items which might be used |
145 | on code paths that handle memory reclaim are required to be queued on |
146 | wq's that have a rescue-worker reserved for execution under memory |
147 | pressure. Else it is possible that the thread-pool deadlocks waiting |
148 | for execution contexts to free up. |
149 | |
150 | |
151 | 4. Application Programming Interface (API) |
152 | |
153 | alloc_workqueue() allocates a wq. The original create_*workqueue() |
154 | functions are deprecated and scheduled for removal. alloc_workqueue() |
155 | takes three arguments - @name, @flags and @max_active. @name is the |
156 | name of the wq and also used as the name of the rescuer thread if |
157 | there is one. |
158 | |
159 | A wq no longer manages execution resources but serves as a domain for |
160 | forward progress guarantee, flush and work item attributes. @flags |
161 | and @max_active control how work items are assigned execution |
162 | resources, scheduled and executed. |
163 | |
164 | @flags: |
165 | |
166 | WQ_NON_REENTRANT |
167 | |
168 | By default, a wq guarantees non-reentrance only on the same |
169 | CPU. A work item may not be executed concurrently on the same |
170 | CPU by multiple workers but is allowed to be executed |
171 | concurrently on multiple CPUs. This flag makes sure |
172 | non-reentrance is enforced across all CPUs. Work items queued |
173 | to a non-reentrant wq are guaranteed to be executed by at most |
174 | one worker system-wide at any given time. |
175 | |
176 | WQ_UNBOUND |
177 | |
178 | Work items queued to an unbound wq are served by a special |
179 | gcwq which hosts workers which are not bound to any specific |
180 | CPU. This makes the wq behave as a simple execution context |
181 | provider without concurrency management. The unbound gcwq |
182 | tries to start execution of work items as soon as possible. |
183 | Unbound wq sacrifices locality but is useful for the following |
184 | cases. |
185 | |
186 | * Wide fluctuation in the concurrency level requirement is |
187 | expected and using bound wq may end up creating large number |
188 | of mostly unused workers across different CPUs as the issuer |
189 | hops through different CPUs. |
190 | |
191 | * Long running CPU intensive workloads which can be better |
192 | managed by the system scheduler. |
193 | |
194 | WQ_FREEZABLE |
195 | |
196 | A freezable wq participates in the freeze phase of the system |
197 | suspend operations. Work items on the wq are drained and no |
198 | new work item starts execution until thawed. |
199 | |
200 | WQ_MEM_RECLAIM |
201 | |
202 | All wq which might be used in the memory reclaim paths _MUST_ |
203 | have this flag set. The wq is guaranteed to have at least one |
204 | execution context regardless of memory pressure. |
205 | |
206 | WQ_HIGHPRI |
207 | |
208 | Work items of a highpri wq are queued at the head of the |
209 | worklist of the target gcwq and start execution regardless of |
210 | the current concurrency level. In other words, highpri work |
211 | items will always start execution as soon as execution |
212 | resource is available. |
213 | |
214 | Ordering among highpri work items is preserved - a highpri |
215 | work item queued after another highpri work item will start |
216 | execution after the earlier highpri work item starts. |
217 | |
218 | Although highpri work items are not held back by other |
219 | runnable work items, they still contribute to the concurrency |
220 | level. Highpri work items in runnable state will prevent |
221 | non-highpri work items from starting execution. |
222 | |
223 | This flag is meaningless for unbound wq. |
224 | |
225 | WQ_CPU_INTENSIVE |
226 | |
227 | Work items of a CPU intensive wq do not contribute to the |
228 | concurrency level. In other words, runnable CPU intensive |
229 | work items will not prevent other work items from starting |
230 | execution. This is useful for bound work items which are |
231 | expected to hog CPU cycles so that their execution is |
232 | regulated by the system scheduler. |
233 | |
234 | Although CPU intensive work items don't contribute to the |
235 | concurrency level, start of their executions is still |
236 | regulated by the concurrency management and runnable |
237 | non-CPU-intensive work items can delay execution of CPU |
238 | intensive work items. |
239 | |
240 | This flag is meaningless for unbound wq. |
241 | |
242 | WQ_HIGHPRI | WQ_CPU_INTENSIVE |
243 | |
244 | This combination makes the wq avoid interaction with |
245 | concurrency management completely and behave as a simple |
246 | per-CPU execution context provider. Work items queued on a |
247 | highpri CPU-intensive wq start execution as soon as resources |
248 | are available and don't affect execution of other work items. |
249 | |
250 | @max_active: |
251 | |
252 | @max_active determines the maximum number of execution contexts per |
253 | CPU which can be assigned to the work items of a wq. For example, |
254 | with @max_active of 16, at most 16 work items of the wq can be |
255 | executing at the same time per CPU. |
256 | |
257 | Currently, for a bound wq, the maximum limit for @max_active is 512 |
258 | and the default value used when 0 is specified is 256. For an unbound |
259 | wq, the limit is higher of 512 and 4 * num_possible_cpus(). These |
260 | values are chosen sufficiently high such that they are not the |
261 | limiting factor while providing protection in runaway cases. |
262 | |
263 | The number of active work items of a wq is usually regulated by the |
264 | users of the wq, more specifically, by how many work items the users |
265 | may queue at the same time. Unless there is a specific need for |
266 | throttling the number of active work items, specifying '0' is |
267 | recommended. |
268 | |
269 | Some users depend on the strict execution ordering of ST wq. The |
270 | combination of @max_active of 1 and WQ_UNBOUND is used to achieve this |
271 | behavior. Work items on such wq are always queued to the unbound gcwq |
272 | and only one work item can be active at any given time thus achieving |
273 | the same ordering property as ST wq. |
274 | |
275 | |
276 | 5. Example Execution Scenarios |
277 | |
278 | The following example execution scenarios try to illustrate how cmwq |
279 | behave under different configurations. |
280 | |
281 | Work items w0, w1, w2 are queued to a bound wq q0 on the same CPU. |
282 | w0 burns CPU for 5ms then sleeps for 10ms then burns CPU for 5ms |
283 | again before finishing. w1 and w2 burn CPU for 5ms then sleep for |
284 | 10ms. |
285 | |
286 | Ignoring all other tasks, works and processing overhead, and assuming |
287 | simple FIFO scheduling, the following is one highly simplified version |
288 | of possible sequences of events with the original wq. |
289 | |
290 | TIME IN MSECS EVENT |
291 | 0 w0 starts and burns CPU |
292 | 5 w0 sleeps |
293 | 15 w0 wakes up and burns CPU |
294 | 20 w0 finishes |
295 | 20 w1 starts and burns CPU |
296 | 25 w1 sleeps |
297 | 35 w1 wakes up and finishes |
298 | 35 w2 starts and burns CPU |
299 | 40 w2 sleeps |
300 | 50 w2 wakes up and finishes |
301 | |
302 | And with cmwq with @max_active >= 3, |
303 | |
304 | TIME IN MSECS EVENT |
305 | 0 w0 starts and burns CPU |
306 | 5 w0 sleeps |
307 | 5 w1 starts and burns CPU |
308 | 10 w1 sleeps |
309 | 10 w2 starts and burns CPU |
310 | 15 w2 sleeps |
311 | 15 w0 wakes up and burns CPU |
312 | 20 w0 finishes |
313 | 20 w1 wakes up and finishes |
314 | 25 w2 wakes up and finishes |
315 | |
316 | If @max_active == 2, |
317 | |
318 | TIME IN MSECS EVENT |
319 | 0 w0 starts and burns CPU |
320 | 5 w0 sleeps |
321 | 5 w1 starts and burns CPU |
322 | 10 w1 sleeps |
323 | 15 w0 wakes up and burns CPU |
324 | 20 w0 finishes |
325 | 20 w1 wakes up and finishes |
326 | 20 w2 starts and burns CPU |
327 | 25 w2 sleeps |
328 | 35 w2 wakes up and finishes |
329 | |
330 | Now, let's assume w1 and w2 are queued to a different wq q1 which has |
331 | WQ_HIGHPRI set, |
332 | |
333 | TIME IN MSECS EVENT |
334 | 0 w1 and w2 start and burn CPU |
335 | 5 w1 sleeps |
336 | 10 w2 sleeps |
337 | 10 w0 starts and burns CPU |
338 | 15 w0 sleeps |
339 | 15 w1 wakes up and finishes |
340 | 20 w2 wakes up and finishes |
341 | 25 w0 wakes up and burns CPU |
342 | 30 w0 finishes |
343 | |
344 | If q1 has WQ_CPU_INTENSIVE set, |
345 | |
346 | TIME IN MSECS EVENT |
347 | 0 w0 starts and burns CPU |
348 | 5 w0 sleeps |
349 | 5 w1 and w2 start and burn CPU |
350 | 10 w1 sleeps |
351 | 15 w2 sleeps |
352 | 15 w0 wakes up and burns CPU |
353 | 20 w0 finishes |
354 | 20 w1 wakes up and finishes |
355 | 25 w2 wakes up and finishes |
356 | |
357 | |
358 | 6. Guidelines |
359 | |
360 | * Do not forget to use WQ_MEM_RECLAIM if a wq may process work items |
361 | which are used during memory reclaim. Each wq with WQ_MEM_RECLAIM |
362 | set has an execution context reserved for it. If there is |
363 | dependency among multiple work items used during memory reclaim, |
364 | they should be queued to separate wq each with WQ_MEM_RECLAIM. |
365 | |
366 | * Unless strict ordering is required, there is no need to use ST wq. |
367 | |
368 | * Unless there is a specific need, using 0 for @max_active is |
369 | recommended. In most use cases, concurrency level usually stays |
370 | well under the default limit. |
371 | |
372 | * A wq serves as a domain for forward progress guarantee |
373 | (WQ_MEM_RECLAIM, flush and work item attributes. Work items which |
374 | are not involved in memory reclaim and don't need to be flushed as a |
375 | part of a group of work items, and don't require any special |
376 | attribute, can use one of the system wq. There is no difference in |
377 | execution characteristics between using a dedicated wq and a system |
378 | wq. |
379 | |
380 | * Unless work items are expected to consume a huge amount of CPU |
381 | cycles, using a bound wq is usually beneficial due to the increased |
382 | level of locality in wq operations and work item execution. |
383 | |
384 | |
385 | 7. Debugging |
386 | |
387 | Because the work functions are executed by generic worker threads |
388 | there are a few tricks needed to shed some light on misbehaving |
389 | workqueue users. |
390 | |
391 | Worker threads show up in the process list as: |
392 | |
393 | root 5671 0.0 0.0 0 0 ? S 12:07 0:00 [kworker/0:1] |
394 | root 5672 0.0 0.0 0 0 ? S 12:07 0:00 [kworker/1:2] |
395 | root 5673 0.0 0.0 0 0 ? S 12:12 0:00 [kworker/0:0] |
396 | root 5674 0.0 0.0 0 0 ? S 12:13 0:00 [kworker/1:0] |
397 | |
398 | If kworkers are going crazy (using too much cpu), there are two types |
399 | of possible problems: |
400 | |
401 | 1. Something beeing scheduled in rapid succession |
402 | 2. A single work item that consumes lots of cpu cycles |
403 | |
404 | The first one can be tracked using tracing: |
405 | |
406 | $ echo workqueue:workqueue_queue_work > /sys/kernel/debug/tracing/set_event |
407 | $ cat /sys/kernel/debug/tracing/trace_pipe > out.txt |
408 | (wait a few secs) |
409 | ^C |
410 | |
411 | If something is busy looping on work queueing, it would be dominating |
412 | the output and the offender can be determined with the work item |
413 | function. |
414 | |
415 | For the second type of problems it should be possible to just check |
416 | the stack trace of the offending worker thread. |
417 | |
418 | $ cat /proc/THE_OFFENDING_KWORKER/stack |
419 | |
420 | The work item's function should be trivially visible in the stack |
421 | trace. |
422 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9