accel/tcg/tcg-accel-ops-rr.c

   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/tcg.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()) {
 113         rr_stop_kick_timer();
 114         qemu_cond_wait_iothread(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_cpus_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     qemu_mutex_lock_iothread();
 192     qemu_thread_get_self(cpu->thread);
 193
 194     cpu->thread_id = qemu_get_thread_id();
 195     cpu->can_do_io = 1;
 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_iothread(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         qemu_mutex_unlock_iothread();
 222         replay_mutex_lock();
 223         qemu_mutex_lock_iothread();
 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                 qemu_mutex_unlock_iothread();
 258                 if (icount_enabled()) {
 259                     icount_prepare_for_run(cpu, cpu_budget);
 260                 }
 261                 r = tcg_cpus_exec(cpu);
 262                 if (icount_enabled()) {
 263                     icount_process_data(cpu);
 264                 }
 265                 qemu_mutex_lock_iothread();
 266
 267                 if (r == EXCP_DEBUG) {
 268                     cpu_handle_guest_debug(cpu);
 269                     break;
 270                 } else if (r == EXCP_ATOMIC) {
 271                     qemu_mutex_unlock_iothread();
 272                     cpu_exec_step_atomic(cpu);
 273                     qemu_mutex_lock_iothread();
 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         cpu->thread = g_new0(QemuThread, 1);
 321         cpu->halt_cond = g_new0(QemuCond, 1);
 322         qemu_cond_init(cpu->halt_cond);
 323
 324         /* share a single thread for all cpus with TCG */
 325         snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "ALL CPUs/TCG");
 326         qemu_thread_create(cpu->thread, thread_name,
 327                            rr_cpu_thread_fn,
 328                            cpu, QEMU_THREAD_JOINABLE);
 329
 330         single_tcg_halt_cond = cpu->halt_cond;
 331         single_tcg_cpu_thread = cpu->thread;
 332     } else {
 333         /* we share the thread */
 334         cpu->thread = single_tcg_cpu_thread;
 335         cpu->halt_cond = single_tcg_halt_cond;
 336         cpu->thread_id = first_cpu->thread_id;
 337         cpu->can_do_io = 1;
 338         cpu->created = true;
 339     }
 340 }