Lines Matching full:cpu0

128  *           migrator = CPU0           migrator = CPU2
129  *           active   = CPU0           active   = CPU2
135  * 1. CPU0 goes idle. As the update is performed group wise, in the first step
136  *    only GRP0:0 is updated. The update of GRP1:0 is pending as CPU0 has to
150  * 2. While CPU0 goes idle and continues to update the state, CPU1 comes out of
152  *    has to walk the hierarchy. Both CPUs (CPU0 and CPU1) now walk the
168  *    step 2) through the hierarchy to GRP1:0 before CPU0 (step 1) did. The
183  * 4. Now CPU0 finally propagates its changes (from step 1) to GRP1:0.
197  * The race of CPU0 vs. CPU1 led to an inconsistent state in GRP1:0. CPU1 is
205  * counter: The update as performed by CPU0 in step 4 will fail. CPU1 changed
207  * seen by CPU0 before starting the walk) does not match.
266  * 4. CPU 0 has a new timer queued from idle and it expires at TIMER0. CPU0
285  *    handed back to CPU0, as it seems that there is still an active child in
304  *   CPU2 (tmigr_inactive_up())          CPU0 (tmigr_new_timer_up())
326  * When CPU0 grabs the lock directly after cmpxchg, the first timer is reported
327  * back to CPU0 and also later on to CPU2. So no timer is missed. A concurrent
339  * 1. CPU0 and CPU1 are idle and have both a global timer expiring at the same
353  *           groupevt.cpu = CPU0       groupevt.cpu =
354  *           timerqueue = evt-CPU0,    timerqueue =
364  *    of CPU0.
375  *       --> groupevt.cpu = CPU0       groupevt.cpu =
376  *           timerqueue = evt-CPU0,    timerqueue =
382  * 3. Some work has to be done after expiring the timers of CPU0. If we stop
384  *    timerqueue of GRP0:0 has still an event for CPU0 enqueued which has just
385  *    been processed. So it is required to walk the hierarchy from CPU0's point
386  *    of view and update it accordingly. CPU0's event will be removed from the
387  *    timerqueue because it has no pending timer. If CPU0 would have a timer