Removed incomplete zone-based implementation.

3 files changed, 17 insertions, 68 deletions

diff --git a/arch/i386/kernel/apic.c b/arch/i386/kernel/apic.c
index df09855f81..f155275295 100644
--- a/arch/i386/kernel/apic.c
+++ b/arch/i386/kernel/apic.c
@@ -26,7 +26,6 @@
 #include <linux/sysdev.h>
 #include <linux/cpu.h>
 #include <linux/module.h>
-#include <linux/sched.h>
 #include <linux/litmus.h>
 
 #include <asm/atomic.h>
@@ -59,16 +58,12 @@ static int enable_local_apic __initdata = 0; /* -1=force-disable, +1=force-enabl
 /*
  * Definitions and variables related to quantum synchronization.
  */
-#define WAIT_TO_SYNC 30000 /* time between syncs and before 1st sync */
+#define WAIT_TO_SYNC 30000 /* time after boot until sync */
 static int stagger = 0; /* are we using staggered quanta? */
 static atomic_t qsync_time = ATOMIC_INIT(INITIAL_JIFFIES);
 static atomic_t quantum_sync_barrier = ATOMIC_INIT(0);
-static atomic_t barrier_use_count = ATOMIC_INIT(1);
 static atomic_t sync_done = ATOMIC_INIT(0);
 
-/* Records time of last local timer interrupt at each processor. */
-DEFINE_PER_CPU(struct timeval, last_local_intr);
-
 static inline void lapic_disable(void)
 {
         enable_local_apic = -1;
@@ -1234,12 +1229,7 @@ EXPORT_SYMBOL(switch_ipi_to_APIC_timer);
  * necessary. It relies on a barrier to synchronize all processors, so
  * that they all reset their APIC timers at the same time. If quanta
  * should be staggered, the appropriate stagger delay is then added at
- * each processor. Staggered quanta are synchronized only once (it is
- * only important that quanta remain relatively misaligned, not that they
- * remain equally spaced forever). Aligned quanta, however, are
- * periodically realigned, which in most cases should not result
- * in timing issues after the first alignment. In order
- * to enable periodic realignment, we use a sense-reversal barrier.
+ * each processor.
  */
 
 void synchronize_quanta(void)
@@ -1254,39 +1244,24 @@ void synchronize_quanta(void)
          */
         disable_APIC_timer();
         atomic_inc(&quantum_sync_barrier);
-        while (atomic_read(&quantum_sync_barrier) <
-               atomic_read(&barrier_use_count) * total_cpus)
-        {
+        while (atomic_read(&quantum_sync_barrier) < total_cpus) {
                 /* Delay, otherwise atomic_inc's cannot occur. */
                 udelay(1);
         }
-        __setup_APIC_LVTT(calibration_result);
-        if (!stagger)
-                enable_APIC_timer();
 
-        /*
-         * Add necessary stagger for this CPU, if required. Do _not_
-         * update qsync_time. Otherwise, we update the qsync_time
-         * and increment the barrier count, which allows the barrier to
-         * be "reused" (at least, until overflow occurs in roughly X*2^29
-         * seconds, or roughly X*17 years -- for a 30 second wait interval,
-         * this means 510 years until overflow, which seems safe).
-         */
+        /* Add necessary stagger for this CPU, if required. */
         if (stagger) {
                 int stagger_us = cpu * stagger_interval;
                 udelay(stagger_us);
-                __setup_APIC_LVTT(calibration_result);
-                enable_APIC_timer();
-                atomic_inc(&sync_done);
-        } else if (cpu == 0) { 
-                /* The first CPU updates qsync_time and "resets" barrier */
-                atomic_inc(&sync_done); /* temporary until resync fixed */
-                /*
-                 * FIXME: wraparound issue prevents periodic re-synch.
-                 */
-/*              atomic_add(msecs_to_jiffies(WAIT_TO_SYNC), &qsync_time); */
-/*              atomic_inc(&barrier_use_count); */
         }
+
+        /* Re-enable all timers. */
+        __setup_APIC_LVTT(calibration_result);
+        enable_APIC_timer();
+        
+        /* The first CPU signals that quantum sync is complete. */
+        if (cpu == 0)
+                atomic_inc(&sync_done); 
 }
 
 
@@ -1302,27 +1277,8 @@ void synchronize_quanta(void)
 
 inline void smp_local_timer_interrupt(void)
 {
-        struct task_struct *p;
         int cpu = smp_processor_id();
 
-        /* 
-         * Read offset from last recorded global tick.
-         * Do this before calling profiling and scheduling code, as
-         * this indicates roughly when a scheduling decision will be made.
-         * Note that we try to read the offset without claiming any locks.
-         * This won't always work, but we just want enough samples
-         * to figure out what's going on.
-         */
-/*      offset = get_nsec_offset();
-        if (jiffies % 10 == 0 && time_after(jiffies, 
-            (unsigned long)(INITIAL_JIFFIES + msecs_to_jiffies(WAIT_TO_SYNC))))
-                TRACE("%d, %d: %lld\n", smp_processor_id(), jiffies, offset);
-*/
-
-        /* Record current time as timestamp of when last local
-         * interrupt occurred. */
-        do_getapproxtimeofday(&(per_cpu(last_local_intr, cpu)));
-
         profile_tick(CPU_PROFILING);
 #ifdef CONFIG_SMP
         update_process_times(user_mode_vm(get_irq_regs()));
@@ -1330,8 +1286,7 @@ inline void smp_local_timer_interrupt(void)
 
         /*
          * Synchronize quanta if we have reached qsync_time plus wait
-         * interval. Note that sync_done is only set in the staggered case.
-         * The synchronization code itself is placed in its own
+         * interval. The synchronization code itself is placed in its own
          * (non-inline) function, to avoid issues with creating an inline
          * function that is too large.
          */
@@ -1342,12 +1297,6 @@ inline void smp_local_timer_interrupt(void)
                 synchronize_quanta();
         }
 
-        /* Clear flags for tasks waiting until end of blocking zone, as it
-         * will end immediately after this interrupt handler exits.
-         */
-        for_each_process(p)
-                p->rt_param.waiting_to_exit_zone = 0;
-
         /*
          * We take the 'long' return path, and there every subsystem
          * grabs the apropriate locks (kernel lock/ irq lock).
diff --git a/arch/i386/kernel/srp_sem_syscalls.c b/arch/i386/kernel/srp_sem_syscalls.c
index 8f0545898c..838df95202 100644
--- a/arch/i386/kernel/srp_sem_syscalls.c
+++ b/arch/i386/kernel/srp_sem_syscalls.c
@@ -1,5 +1,7 @@
 #ifdef __KERNEL__
 
+// comparison by period and pid!
+
 /*
  * Uniprocessor SRP "semaphores".
  */
diff --git a/arch/i386/kernel/syscall_table.S b/arch/i386/kernel/syscall_table.S
index 0b50716b03..9a5348f209 100644
--- a/arch/i386/kernel/syscall_table.S
+++ b/arch/i386/kernel/syscall_table.S
@@ -339,10 +339,8 @@ ENTRY(sys_call_table)
         .long sys_down
         .long sys_up
         .long sys_sema_free
-        .long sys_in_blocking_zone
-        .long sys_wait_for_zone_exit    /* 340 */
         .long sys_srp_sema_init
-        .long sys_srp_down
+        .long sys_srp_down              /* 340 */
         .long sys_srp_up
         .long sys_reg_task_srp_sem
-        .long sys_srp_sema_free         /* 345 */
+        .long sys_srp_sema_free         /* 343 */