Added support for quantum synchronization by having all processors wait

on a barrier, after which all timers are reset concurrently. This is still
being debugged -- I locally committed it so it would be backed up
somewhere.

2 files changed, 55 insertions, 1 deletions

diff --git a/Makefile b/Makefile
index 7e2750f4ca..6c433547cd 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 VERSION = 2
 PATCHLEVEL = 6
 SUBLEVEL = 20
-EXTRAVERSION =
+EXTRAVERSION = -jmc
 NAME = Homicidal Dwarf Hamster
 
 # *DOCUMENTATION*
diff --git a/arch/i386/kernel/apic.c b/arch/i386/kernel/apic.c
index 776d9be26a..268a32870c 100644
--- a/arch/i386/kernel/apic.c
+++ b/arch/i386/kernel/apic.c
@@ -1197,6 +1197,44 @@ EXPORT_SYMBOL(switch_ipi_to_APIC_timer);
 
 #undef APIC_DIVISOR
 
+/* JOHN: Begin added code, starting with quantum sync function. */
+#define STAGGER 0
+#define WARM_UP_INTRS 10000
+        // later, define per-cpu variable and re-synch when intr_count % WARM_UP_INTRS == 0
+static atomic_t quantum_sync_barrier = ATOMIC_INIT(0); // used to implement simple barrier
+static DEFINE_PER_CPU(int, synched) = 0;
+
+/* This function is called to align all quanta, and to stagger quanta if necessary. */
+void synchronize_quanta(void)
+{
+        int cpu = smp_processor_id();
+        int total_cpus = num_online_cpus();
+        int stagger_interval = jiffies_to_usecs(1)/total_cpus;
+
+        /*
+         * Disable APIC timer, wait for all other processors to reach barrier,
+         * and re-enable all timers concurrently.
+         */
+        disable_APIC_timer();
+        atomic_inc(&quantum_sync_barrier);
+        while (atomic_read(&quantum_sync_barrier) < total_cpus);
+        __setup_APIC_LVTT(calibration_result);
+        enable_APIC_timer();
+
+        /* Add necessary stagger for this CPU, if required. */
+        if (STAGGER) {
+                int stagger_us = cpu*stagger_interval;
+                disable_APIC_timer();
+                udelay(stagger_us);
+                __setup_APIC_LVTT(calibration_result);
+                enable_APIC_timer();
+        }
+
+        /* Set "synched" flag so this code is not executed again. */
+        per_cpu(synched, cpu) = 1;
+}
+/* JOHN: end added code. */
+
 /*
  * Local timer interrupt handler. It does both profiling and
  * process statistics/rescheduling.
@@ -1209,11 +1247,27 @@ EXPORT_SYMBOL(switch_ipi_to_APIC_timer);
 
 inline void smp_local_timer_interrupt(void)
 {
+        // JOHN: begin added code.
+        int cpu = smp_processor_id();
+        // JOHN: end added code.
+
         profile_tick(CPU_PROFILING);
 #ifdef CONFIG_SMP
         update_process_times(user_mode_vm(get_irq_regs()));
 #endif
 
+        // JOHN: begin added code.
+        /*
+         * Time to synchronize quanta, if it hasn't been done already. To avoid
+         * placing a lot of code in an inline function, the actual sync code is
+         * placed in its own (non-inline) function - the majority of the time
+         * we won't even call it.
+         */
+        if (unlikely(!per_cpu(synched, cpu))) {
+                synchronize_quanta();
+        }
+        // JOHN: end added code.
+
         /*
          * We take the 'long' return path, and there every subsystem
          * grabs the apropriate locks (kernel lock/ irq lock).