qemu: refactor main_loop (Marcelo Tosatti)

Break main loop into 3 main functions.

Signed-off-by: Marcelo Tosatti <mtosatti@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@7241 c046a42c-6fe2-441c-8c8c-71466251a162

vl.c

@@ -273,7 +273,7 @@ uint64_t node_cpumask[MAX_NODES];
 
 static CPUState *cur_cpu;
 static CPUState *next_cpu;
-static int event_pending = 1;
+static int timer_alarm_pending = 1;
 /* Conversion factor from emulated instructions to virtual clock ticks.  */
 static int icount_time_shift;
 /* Arbitrarily pick 1MIPS as the minimum allowable speed.  */
@@ -1360,7 +1360,7 @@ static void host_alarm_handler(int host_signum)
             }
 #endif
         }
-        event_pending = 1;
+        timer_alarm_pending = 1;
         qemu_notify_event();
     }
 }
@@ -3879,22 +3879,13 @@ void main_loop_wait(int timeout)
 
 }
 
-static int main_loop(void)
+static int qemu_cpu_exec(CPUState *env)
 {
-    int ret, timeout;
+    int ret;
 #ifdef CONFIG_PROFILER
     int64_t ti;
 #endif
-    CPUState *env;
 
-    cur_cpu = first_cpu;
-    next_cpu = cur_cpu->next_cpu ?: first_cpu;
-    for(;;) {
-        if (vm_running) {
-
-            for(;;) {
-                /* get next cpu */
-                env = next_cpu;
 #ifdef CONFIG_PROFILER
     ti = profile_getclock();
 #endif
@@ -3925,52 +3916,40 @@ static int main_loop(void)
         env->icount_decr.u32 = 0;
         env->icount_extra = 0;
     }
-                next_cpu = env->next_cpu ?: first_cpu;
+    return ret;
-                if (event_pending && likely(ret != EXCP_DEBUG)) {
-                    ret = EXCP_INTERRUPT;
-                    event_pending = 0;
-                    break;
 }
-                if (ret == EXCP_HLT) {
-                    /* Give the next CPU a chance to run.  */
-                    cur_cpu = env;
-                    continue;
-                }
-                if (ret != EXCP_HALTED)
-                    break;
-                /* all CPUs are halted ? */
-                if (env == cur_cpu)
-                    break;
-            }
-            cur_cpu = env;
 
-            if (shutdown_requested) {
+static int cpu_has_work(CPUState *env)
-                ret = EXCP_INTERRUPT;
+{
-                if (no_shutdown) {
+    if (!env->halted)
-                    vm_stop(0);
+        return 1;
-                    no_shutdown = 0;
+    if (qemu_cpu_has_work(env))
+        return 1;
+    return 0;
 }
-                else
+
-                    break;
+static int tcg_has_work(void)
+{
+    CPUState *env;
+
+    for (env = first_cpu; env != NULL; env = env->next_cpu)
+        if (cpu_has_work(env))
+            return 1;
+    return 0;
 }
-            if (reset_requested) {
+
-                reset_requested = 0;
+static int qemu_calculate_timeout(void)
-                qemu_system_reset();
+{
-                ret = EXCP_INTERRUPT;
+    int timeout;
-            }
+
-            if (powerdown_requested) {
+    if (!vm_running)
-                powerdown_requested = 0;
+        timeout = 5000;
-		qemu_system_powerdown();
+    else if (tcg_has_work())
-                ret = EXCP_INTERRUPT;
+        timeout = 0;
-            }
+    else if (!use_icount)
-            if (unlikely(ret == EXCP_DEBUG)) {
+        timeout = 5000;
-                gdb_set_stop_cpu(cur_cpu);
+    else {
-                vm_stop(EXCP_DEBUG);
-            }
-            /* If all cpus are halted then wait until the next IRQ */
      /* XXX: use timeout computed from timers */
-            if (ret == EXCP_HALTED) {
-                if (use_icount) {
         int64_t add;
         int64_t delta;
         /* Advance virtual time to the next event.  */
@@ -4003,29 +3982,72 @@ static int main_loop(void)
             if (timeout < 0)
                 timeout = 0;
         }
-                } else {
-                    timeout = 5000;
     }
-            } else {
+
-                timeout = 0;
+    return timeout;
 }
-        } else {
+
-            if (shutdown_requested) {
+static int vm_can_run(void)
-                ret = EXCP_INTERRUPT;
+{
+    if (powerdown_requested)
+        return 0;
+    if (reset_requested)
+        return 0;
+    if (shutdown_requested)
+        return 0;
+    return 1;
+}
+
+static void main_loop(void)
+{
+    int ret = 0;
+#ifdef CONFIG_PROFILER
+    int64_t ti;
+#endif
+
+    for (;;) {
+        do {
+            if (next_cpu == NULL)
+                next_cpu = first_cpu;
+            for (; next_cpu != NULL; next_cpu = next_cpu->next_cpu) {
+                CPUState *env = cur_cpu = next_cpu;
+
+                if (!vm_running)
+                    break;
+                if (timer_alarm_pending) {
+                    timer_alarm_pending = 0;
+                    break;
+                }
+                ret = qemu_cpu_exec(env);
+                if (ret == EXCP_DEBUG) {
+                    gdb_set_stop_cpu(env);
                     break;
                 }
-            timeout = 5000;
             }
 #ifdef CONFIG_PROFILER
             ti = profile_getclock();
 #endif
-        main_loop_wait(timeout);
+            main_loop_wait(qemu_calculate_timeout());
 #ifdef CONFIG_PROFILER
             dev_time += profile_getclock() - ti;
 #endif
+        } while (ret != EXCP_DEBUG && vm_can_run());
+
+        if (ret == EXCP_DEBUG)
+            vm_stop(EXCP_DEBUG);
+
+        if (qemu_shutdown_requested()) {
+            if (no_shutdown) {
+                vm_stop(0);
+                no_shutdown = 0;
+            } else
+                break;
+        }
+        if (qemu_reset_requested())
+            qemu_system_reset();
+        if (qemu_powerdown_requested())
+            qemu_system_powerdown();
     }
-    cpu_disable_ticks();
-    return ret;
 }
 
 static void version(void)