]>
Commit | Line | Data |
---|---|---|
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. |