X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=includes%2FSMP.h;h=0e6322d40b29a779e7552219cf168a0caade0d5b;hp=515516a9824864ccb7756b65917f9321097f24b6;hb=9131f4adaf4db771a0a628f9e043693ff90a104b;hpb=7adc29e83d11ced8877490f0a12fd8b751b9922a

diff --git a/includes/SMP.h b/includes/SMP.h
index 515516a..0e6322d 100644
--- a/includes/SMP.h
+++ b/includes/SMP.h
@@ -1,8 +1,8 @@
 /* ----------------------------------------------------------------------------
  *
- * (c) The GHC Team, 2005
+ * (c) The GHC Team, 2005-2008
  *
- * Macros for THREADED_RTS support
+ * Macros for multi-CPU support
  *
  * -------------------------------------------------------------------------- */
 
@@ -16,16 +16,54 @@
  *      Unregisterised builds are ok, but only 1 CPU supported.
  */
 
+#ifdef CMINUSMINUS
+
+#define unlockClosure(ptr,info)                 \
+    prim %write_barrier() [];                   \
+    StgHeader_info(ptr) = info;    
+
+#else
+
 #if defined(THREADED_RTS)
 
 #if  defined(TICKY_TICKY)
 #error Build options incompatible with THREADED_RTS.
 #endif
 
+/* ----------------------------------------------------------------------------
+   Atomic operations
+   ------------------------------------------------------------------------- */
+   
 /* 
- * XCHG - the atomic exchange instruction.  Used for locking closures
- * during updates (see lockClosure() below) and the MVar primops.
+ * The atomic exchange operation: xchg(p,w) exchanges the value
+ * pointed to by p with the value w, returning the old value.
  *
+ * Used for locking closures during updates (see lockClosure() below)
+ * and the MVar primops.
+ */
+INLINE_HEADER StgWord xchg(StgPtr p, StgWord w);
+
+/* 
+ * Compare-and-swap.  Atomically does this:
+ *
+ * cas(p,o,n) { 
+ *    r = *p; 
+ *    if (r == o) { *p = n }; 
+ *    return r;
+ * }
+ */
+INLINE_HEADER StgWord cas(StgVolatilePtr p, StgWord o, StgWord n);
+
+/*
+ * Prevents write operations from moving across this call in either
+ * direction.
+ */ 
+INLINE_HEADER void write_barrier(void);
+
+/* ----------------------------------------------------------------------------
+   Implementations
+   ------------------------------------------------------------------------- */
+/* 
  * NB: the xchg instruction is implicitly locked, so we do not need
  * a lock prefix here. 
  */
@@ -45,9 +83,19 @@ xchg(StgPtr p, StgWord w)
         "1:     lwarx     %0, 0, %2\n"
         "       stwcx.    %1, 0, %2\n"
         "       bne-      1b"
-        :"=r" (result)
+        :"=&r" (result)
         :"r" (w), "r" (p)
     );
+#elif sparc_HOST_ARCH
+    result = w;
+    __asm__ __volatile__ (
+        "swap %1,%0"
+	: "+r" (result), "+m" (*p)
+	: /* no input-only operands */
+      );
+#elif !defined(WITHSMP)
+    result = *p;
+    *p = w;
 #else
 #error xchg() unimplemented on this architecture
 #endif
@@ -63,7 +111,7 @@ cas(StgVolatilePtr p, StgWord o, StgWord n)
 {
 #if i386_HOST_ARCH || x86_64_HOST_ARCH
     __asm__ __volatile__ (
- 	  "lock/cmpxchg %3,%1"
+ 	  "lock\ncmpxchg %3,%1"
           :"=a"(o), "=m" (*(volatile unsigned int *)p) 
           :"0" (o), "r" (n));
     return o;
@@ -81,6 +129,21 @@ cas(StgVolatilePtr p, StgWord o, StgWord n)
         :"cc", "memory"
     );
     return result;
+#elif sparc_HOST_ARCH
+    __asm__ __volatile__ (
+	"cas [%1], %2, %0"
+	: "+r" (n)
+	: "r" (p), "r" (o)
+	: "memory"
+    );
+    return n;
+#elif !defined(WITHSMP)
+    StgWord result;
+    result = *p;
+    if (result == o) {
+        *p = n;
+    }
+    return result;
 #else
 #error cas() unimplemented on this architecture
 #endif
@@ -102,48 +165,17 @@ write_barrier(void) {
     __asm__ __volatile__ ("" : : : "memory");
 #elif powerpc_HOST_ARCH
     __asm__ __volatile__ ("lwsync" : : : "memory");
+#elif sparc_HOST_ARCH
+    /* Sparc in TSO mode does not require write/write barriers. */
+    __asm__ __volatile__ ("" : : : "memory");
+#elif !defined(WITHSMP)
+    return;
 #else
 #error memory barriers unimplemented on this architecture
 #endif
 }
 
-/*
- * Locking/unlocking closures
- *
- * This is used primarily in the implementation of MVars.
- */
-#define SPIN_COUNT 4000
-
-INLINE_HEADER StgInfoTable *
-lockClosure(StgClosure *p)
-{
-#if i386_HOST_ARCH || x86_64_HOST_ARCH || powerpc_HOST_ARCH
-    StgWord info;
-    do {
-	nat i = 0;
-	do {
-	    info = xchg((P_)(void *)&p->header.info, (W_)&stg_WHITEHOLE_info);
-	    if (info != (W_)&stg_WHITEHOLE_info) return (StgInfoTable *)info;
-	} while (++i < SPIN_COUNT);
-	yieldThread();
-    } while (1);
-#else
-   ACQUIRE_SM_LOCK
-#endif
-}
-
-INLINE_HEADER void
-unlockClosure(StgClosure *p, StgInfoTable *info)
-{
-#if i386_HOST_ARCH || x86_64_HOST_ARCH || powerpc_HOST_ARCH
-    // This is a strictly ordered write, so we need a wb():
-    write_barrier();
-    p->header.info = info;
-#else
-    RELEASE_SM_LOCK;
-#endif
-}
-
+/* ---------------------------------------------------------------------- */
 #else /* !THREADED_RTS */
 
 #define write_barrier() /* nothing */
@@ -156,21 +188,8 @@ xchg(StgPtr p, StgWord w)
     return old;
 }
 
-INLINE_HEADER StgInfoTable *
-lockClosure(StgClosure *p)
-{ return (StgInfoTable *)p->header.info; }
-
-INLINE_HEADER void
-unlockClosure(StgClosure *p STG_UNUSED, StgInfoTable *info STG_UNUSED)
-{ /* nothing */ }
-
 #endif /* !THREADED_RTS */
 
-// Handy specialised versions of lockClosure()/unlockClosure()
-INLINE_HEADER void lockTSO(StgTSO *tso)
-{ lockClosure((StgClosure *)tso); }
-
-INLINE_HEADER void unlockTSO(StgTSO *tso)
-{ unlockClosure((StgClosure*)tso, (StgInfoTable*)&stg_TSO_info); }
+#endif /* CMINUSMINUS */
 
 #endif /* SMP_H */