Pull esi-support into release branch

[linux-2.6] / arch / powerpc / platforms / cell / spufs / sched.c

diff --git a/arch/powerpc/platforms/cell/spufs/sched.c b/arch/powerpc/platforms/cell/spufs/sched.c
index e2f10b5b8a6af69dfc027b6b30c66510551ef4dc..1350294484b62e191a131daa99dbd6f8de51aab2 100644 (file)
--- a/arch/powerpc/platforms/cell/spufs/sched.c
+++ b/arch/powerpc/platforms/cell/spufs/sched.c
@@ -26,7 +26,6 @@
 
 #undef DEBUG
 
-#include <linux/config.h>
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
@@ -43,8 +42,11 @@
 #include <asm/mmu_context.h>
 #include <asm/spu.h>
 #include <asm/spu_csa.h>
+#include <asm/spu_priv1.h>
 #include "spufs.h"
 
+#define SPU_MIN_TIMESLICE      (100 * HZ / 1000)
+
 #define SPU_BITMAP_SIZE (((MAX_PRIO+BITS_PER_LONG)/BITS_PER_LONG)+1)
 struct spu_prio_array {
        atomic_t nr_blocked;
@@ -168,6 +170,7 @@ static inline void bind_context(struct spu *spu, struct spu_context *ctx)
                 spu->number);
        spu->ctx = ctx;
        spu->flags = 0;
+       ctx->flags = 0;
        ctx->spu = spu;
        ctx->ops = &spu_hw_ops;
        spu->pid = current->pid;
@@ -177,9 +180,11 @@ static inline void bind_context(struct spu *spu, struct spu_context *ctx)
        spu->ibox_callback = spufs_ibox_callback;
        spu->wbox_callback = spufs_wbox_callback;
        spu->stop_callback = spufs_stop_callback;
+       spu->mfc_callback = spufs_mfc_callback;
        mb();
        spu_unmap_mappings(ctx);
        spu_restore(&ctx->csa, spu);
+       spu->timestamp = jiffies;
 }
 
 static inline void unbind_context(struct spu *spu, struct spu_context *ctx)
@@ -188,47 +193,73 @@ static inline void unbind_context(struct spu *spu, struct spu_context *ctx)
                 spu->pid, spu->number);
        spu_unmap_mappings(ctx);
        spu_save(&ctx->csa, spu);
+       spu->timestamp = jiffies;
        ctx->state = SPU_STATE_SAVED;
        spu->ibox_callback = NULL;
        spu->wbox_callback = NULL;
        spu->stop_callback = NULL;
+       spu->mfc_callback = NULL;
        spu->mm = NULL;
        spu->pid = 0;
        spu->prio = MAX_PRIO;
        ctx->ops = &spu_backing_ops;
        ctx->spu = NULL;
+       ctx->flags = 0;
+       spu->flags = 0;
        spu->ctx = NULL;
 }
 
-static struct spu *preempt_active(struct spu_runqueue *rq)
+static void spu_reaper(void *data)
 {
-       struct list_head *p;
-       struct spu *worst, *spu;
+       struct spu_context *ctx = data;
+       struct spu *spu;
 
-       worst = list_entry(rq->active_list.next, struct spu, sched_list);
-       list_for_each(p, &rq->active_list) {
-               spu = list_entry(p, struct spu, sched_list);
-               if (spu->prio > worst->prio) {
-                       worst = spu;
+       down_write(&ctx->state_sema);
+       spu = ctx->spu;
+       if (spu && test_bit(SPU_CONTEXT_PREEMPT, &ctx->flags)) {
+               if (atomic_read(&spu->rq->prio.nr_blocked)) {
+                       pr_debug("%s: spu=%d\n", __func__, spu->number);
+                       ctx->ops->runcntl_stop(ctx);
+                       spu_deactivate(ctx);
+                       wake_up_all(&ctx->stop_wq);
+               } else {
+                       clear_bit(SPU_CONTEXT_PREEMPT, &ctx->flags);
                }
        }
-       if (current->prio < worst->prio) {
-               struct spu_context *ctx = worst->ctx;
+       up_write(&ctx->state_sema);
+       put_spu_context(ctx);
+}
 
-               spu = worst;
-               if (down_write_trylock(&ctx->state_sema)) {
-                       pr_debug("%s: booting pid=%d from SPU %d\n",
-                                __FUNCTION__, spu->pid, spu->number);
-                       del_active(rq, spu);
-                       up(&rq->sem);
-                       wake_up_all(&ctx->stop_wq);
-                       ctx->ops->runcntl_stop(ctx);
-                       unbind_context(spu, ctx);
-                       up_write(&ctx->state_sema);
-                       return spu;
+static void schedule_spu_reaper(struct spu_runqueue *rq, struct spu *spu)
+{
+       struct spu_context *ctx = get_spu_context(spu->ctx);
+       unsigned long now = jiffies;
+       unsigned long expire = spu->timestamp + SPU_MIN_TIMESLICE;
+
+       set_bit(SPU_CONTEXT_PREEMPT, &ctx->flags);
+       INIT_WORK(&ctx->reap_work, spu_reaper, ctx);
+       if (time_after(now, expire))
+               schedule_work(&ctx->reap_work);
+       else
+               schedule_delayed_work(&ctx->reap_work, expire - now);
+}
+
+static void check_preempt_active(struct spu_runqueue *rq)
+{
+       struct list_head *p;
+       struct spu *worst = NULL;
+
+       list_for_each(p, &rq->active_list) {
+               struct spu *spu = list_entry(p, struct spu, sched_list);
+               struct spu_context *ctx = spu->ctx;
+               if (!test_bit(SPU_CONTEXT_PREEMPT, &ctx->flags)) {
+                       if (!worst || (spu->prio > worst->prio)) {
+                               worst = spu;
+                       }
                }
        }
-       return NULL;
+       if (worst && (current->prio < worst->prio))
+               schedule_spu_reaper(rq, worst);
 }
 
 static struct spu *get_idle_spu(struct spu_context *ctx, u64 flags)
@@ -256,10 +287,7 @@ static struct spu *get_idle_spu(struct spu_context *ctx, u64 flags)
                                continue;
                        }
                } else {
-                       if (is_best_prio(rq)) {
-                               if ((spu = preempt_active(rq)) != NULL)
-                                       return spu;
-                       }
+                       check_preempt_active(rq);
                        prio_wait(rq, ctx, flags);
                        if (signal_pending(current)) {
                                prio_wakeup(rq);
@@ -331,6 +359,11 @@ int spu_activate(struct spu_context *ctx, u64 flags)
        if (!spu)
                return (signal_pending(current)) ? -ERESTARTSYS : -EAGAIN;
        bind_context(spu, ctx);
+       /*
+        * We're likely to wait for interrupts on the same
+        * CPU that we are now on, so send them here.
+        */
+       spu_cpu_affinity_set(spu, raw_smp_processor_id());
        put_active_spu(spu);
        return 0;
 }
@@ -361,6 +394,8 @@ void spu_yield(struct spu_context *ctx)
                spu_deactivate(ctx);
                ctx->state = SPU_STATE_SAVED;
                need_yield = 1;
+       } else if (spu) {
+               spu->prio = MAX_PRIO;
        }
        up_write(&ctx->state_sema);
        if (unlikely(need_yield))
@@ -399,6 +434,7 @@ int __init spu_sched_init(void)
                pr_debug("%s: adding SPU[%d]\n", __FUNCTION__, spu->number);
                add_idle(rq, spu);
                spu->rq = rq;
+               spu->timestamp = jiffies;
        }
        if (!rq->nr_idle) {
                printk(KERN_WARNING "%s: No available SPUs.\n", __FUNCTION__);