xref: /openbmc/qemu/accel/tcg/tcg-accel-ops-rr.c (revision daff9f7f)
1 /*
2  * QEMU TCG Single Threaded vCPUs implementation
3  *
4  * Copyright (c) 2003-2008 Fabrice Bellard
5  * Copyright (c) 2014 Red Hat Inc.
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a copy
8  * of this software and associated documentation files (the "Software"), to deal
9  * in the Software without restriction, including without limitation the rights
10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11  * copies of the Software, and to permit persons to whom the Software is
12  * furnished to do so, subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included in
15  * all copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23  * THE SOFTWARE.
24  */
25 
26 #include "qemu/osdep.h"
27 #include "qemu/lockable.h"
28 #include "sysemu/tcg.h"
29 #include "sysemu/replay.h"
30 #include "sysemu/cpu-timers.h"
31 #include "qemu/main-loop.h"
32 #include "qemu/notify.h"
33 #include "qemu/guest-random.h"
34 #include "exec/exec-all.h"
35 #include "tcg/startup.h"
36 #include "tcg-accel-ops.h"
37 #include "tcg-accel-ops-rr.h"
38 #include "tcg-accel-ops-icount.h"
39 
40 /* Kick all RR vCPUs */
41 void rr_kick_vcpu_thread(CPUState *unused)
42 {
43     CPUState *cpu;
44 
45     CPU_FOREACH(cpu) {
46         cpu_exit(cpu);
47     };
48 }
49 
50 /*
51  * TCG vCPU kick timer
52  *
53  * The kick timer is responsible for moving single threaded vCPU
54  * emulation on to the next vCPU. If more than one vCPU is running a
55  * timer event we force a cpu->exit so the next vCPU can get
56  * scheduled.
57  *
58  * The timer is removed if all vCPUs are idle and restarted again once
59  * idleness is complete.
60  */
61 
62 static QEMUTimer *rr_kick_vcpu_timer;
63 static CPUState *rr_current_cpu;
64 
65 static inline int64_t rr_next_kick_time(void)
66 {
67     return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + TCG_KICK_PERIOD;
68 }
69 
70 /* Kick the currently round-robin scheduled vCPU to next */
71 static void rr_kick_next_cpu(void)
72 {
73     CPUState *cpu;
74     do {
75         cpu = qatomic_read(&rr_current_cpu);
76         if (cpu) {
77             cpu_exit(cpu);
78         }
79         /* Finish kicking this cpu before reading again.  */
80         smp_mb();
81     } while (cpu != qatomic_read(&rr_current_cpu));
82 }
83 
84 static void rr_kick_thread(void *opaque)
85 {
86     timer_mod(rr_kick_vcpu_timer, rr_next_kick_time());
87     rr_kick_next_cpu();
88 }
89 
90 static void rr_start_kick_timer(void)
91 {
92     if (!rr_kick_vcpu_timer && CPU_NEXT(first_cpu)) {
93         rr_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
94                                            rr_kick_thread, NULL);
95     }
96     if (rr_kick_vcpu_timer && !timer_pending(rr_kick_vcpu_timer)) {
97         timer_mod(rr_kick_vcpu_timer, rr_next_kick_time());
98     }
99 }
100 
101 static void rr_stop_kick_timer(void)
102 {
103     if (rr_kick_vcpu_timer && timer_pending(rr_kick_vcpu_timer)) {
104         timer_del(rr_kick_vcpu_timer);
105     }
106 }
107 
108 static void rr_wait_io_event(void)
109 {
110     CPUState *cpu;
111 
112     while (all_cpu_threads_idle() && replay_can_wait()) {
113         rr_stop_kick_timer();
114         qemu_cond_wait_bql(first_cpu->halt_cond);
115     }
116 
117     rr_start_kick_timer();
118 
119     CPU_FOREACH(cpu) {
120         qemu_wait_io_event_common(cpu);
121     }
122 }
123 
124 /*
125  * Destroy any remaining vCPUs which have been unplugged and have
126  * finished running
127  */
128 static void rr_deal_with_unplugged_cpus(void)
129 {
130     CPUState *cpu;
131 
132     CPU_FOREACH(cpu) {
133         if (cpu->unplug && !cpu_can_run(cpu)) {
134             tcg_cpu_destroy(cpu);
135             break;
136         }
137     }
138 }
139 
140 static void rr_force_rcu(Notifier *notify, void *data)
141 {
142     rr_kick_next_cpu();
143 }
144 
145 /*
146  * Calculate the number of CPUs that we will process in a single iteration of
147  * the main CPU thread loop so that we can fairly distribute the instruction
148  * count across CPUs.
149  *
150  * The CPU count is cached based on the CPU list generation ID to avoid
151  * iterating the list every time.
152  */
153 static int rr_cpu_count(void)
154 {
155     static unsigned int last_gen_id = ~0;
156     static int cpu_count;
157     CPUState *cpu;
158 
159     QEMU_LOCK_GUARD(&qemu_cpu_list_lock);
160 
161     if (cpu_list_generation_id_get() != last_gen_id) {
162         cpu_count = 0;
163         CPU_FOREACH(cpu) {
164             ++cpu_count;
165         }
166         last_gen_id = cpu_list_generation_id_get();
167     }
168 
169     return cpu_count;
170 }
171 
172 /*
173  * In the single-threaded case each vCPU is simulated in turn. If
174  * there is more than a single vCPU we create a simple timer to kick
175  * the vCPU and ensure we don't get stuck in a tight loop in one vCPU.
176  * This is done explicitly rather than relying on side-effects
177  * elsewhere.
178  */
179 
180 static void *rr_cpu_thread_fn(void *arg)
181 {
182     Notifier force_rcu;
183     CPUState *cpu = arg;
184 
185     assert(tcg_enabled());
186     rcu_register_thread();
187     force_rcu.notify = rr_force_rcu;
188     rcu_add_force_rcu_notifier(&force_rcu);
189     tcg_register_thread();
190 
191     bql_lock();
192     qemu_thread_get_self(cpu->thread);
193 
194     cpu->thread_id = qemu_get_thread_id();
195     cpu->neg.can_do_io = true;
196     cpu_thread_signal_created(cpu);
197     qemu_guest_random_seed_thread_part2(cpu->random_seed);
198 
199     /* wait for initial kick-off after machine start */
200     while (first_cpu->stopped) {
201         qemu_cond_wait_bql(first_cpu->halt_cond);
202 
203         /* process any pending work */
204         CPU_FOREACH(cpu) {
205             current_cpu = cpu;
206             qemu_wait_io_event_common(cpu);
207         }
208     }
209 
210     rr_start_kick_timer();
211 
212     cpu = first_cpu;
213 
214     /* process any pending work */
215     cpu->exit_request = 1;
216 
217     while (1) {
218         /* Only used for icount_enabled() */
219         int64_t cpu_budget = 0;
220 
221         bql_unlock();
222         replay_mutex_lock();
223         bql_lock();
224 
225         if (icount_enabled()) {
226             int cpu_count = rr_cpu_count();
227 
228             /* Account partial waits to QEMU_CLOCK_VIRTUAL.  */
229             icount_account_warp_timer();
230             /*
231              * Run the timers here.  This is much more efficient than
232              * waking up the I/O thread and waiting for completion.
233              */
234             icount_handle_deadline();
235 
236             cpu_budget = icount_percpu_budget(cpu_count);
237         }
238 
239         replay_mutex_unlock();
240 
241         if (!cpu) {
242             cpu = first_cpu;
243         }
244 
245         while (cpu && cpu_work_list_empty(cpu) && !cpu->exit_request) {
246             /* Store rr_current_cpu before evaluating cpu_can_run().  */
247             qatomic_set_mb(&rr_current_cpu, cpu);
248 
249             current_cpu = cpu;
250 
251             qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
252                               (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
253 
254             if (cpu_can_run(cpu)) {
255                 int r;
256 
257                 bql_unlock();
258                 if (icount_enabled()) {
259                     icount_prepare_for_run(cpu, cpu_budget);
260                 }
261                 r = tcg_cpu_exec(cpu);
262                 if (icount_enabled()) {
263                     icount_process_data(cpu);
264                 }
265                 bql_lock();
266 
267                 if (r == EXCP_DEBUG) {
268                     cpu_handle_guest_debug(cpu);
269                     break;
270                 } else if (r == EXCP_ATOMIC) {
271                     bql_unlock();
272                     cpu_exec_step_atomic(cpu);
273                     bql_lock();
274                     break;
275                 }
276             } else if (cpu->stop) {
277                 if (cpu->unplug) {
278                     cpu = CPU_NEXT(cpu);
279                 }
280                 break;
281             }
282 
283             cpu = CPU_NEXT(cpu);
284         } /* while (cpu && !cpu->exit_request).. */
285 
286         /* Does not need a memory barrier because a spurious wakeup is okay.  */
287         qatomic_set(&rr_current_cpu, NULL);
288 
289         if (cpu && cpu->exit_request) {
290             qatomic_set_mb(&cpu->exit_request, 0);
291         }
292 
293         if (icount_enabled() && all_cpu_threads_idle()) {
294             /*
295              * When all cpus are sleeping (e.g in WFI), to avoid a deadlock
296              * in the main_loop, wake it up in order to start the warp timer.
297              */
298             qemu_notify_event();
299         }
300 
301         rr_wait_io_event();
302         rr_deal_with_unplugged_cpus();
303     }
304 
305     rcu_remove_force_rcu_notifier(&force_rcu);
306     rcu_unregister_thread();
307     return NULL;
308 }
309 
310 void rr_start_vcpu_thread(CPUState *cpu)
311 {
312     char thread_name[VCPU_THREAD_NAME_SIZE];
313     static QemuCond *single_tcg_halt_cond;
314     static QemuThread *single_tcg_cpu_thread;
315 
316     g_assert(tcg_enabled());
317     tcg_cpu_init_cflags(cpu, false);
318 
319     if (!single_tcg_cpu_thread) {
320         single_tcg_halt_cond = cpu->halt_cond;
321         single_tcg_cpu_thread = cpu->thread;
322 
323         /* share a single thread for all cpus with TCG */
324         snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "ALL CPUs/TCG");
325         qemu_thread_create(cpu->thread, thread_name,
326                            rr_cpu_thread_fn,
327                            cpu, QEMU_THREAD_JOINABLE);
328     } else {
329         /* we share the thread, dump spare data */
330         g_free(cpu->thread);
331         qemu_cond_destroy(cpu->halt_cond);
332         g_free(cpu->halt_cond);
333         cpu->thread = single_tcg_cpu_thread;
334         cpu->halt_cond = single_tcg_halt_cond;
335 
336         /* copy the stuff done at start of rr_cpu_thread_fn */
337         cpu->thread_id = first_cpu->thread_id;
338         cpu->neg.can_do_io = 1;
339         cpu->created = true;
340     }
341 }
342