Changeset: 3de7db09922e for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=3de7db09922e
Modified Files:
        gdk/gdk_utils.c
Branch: Feb2013
Log Message:

Use atomic instructions for GDKstopped variable.
Getting rid of GDKstoppedLock for systems that support the atomic
instructions.


diffs (290 lines):

diff --git a/gdk/gdk_utils.c b/gdk/gdk_utils.c
--- a/gdk/gdk_utils.c
+++ b/gdk/gdk_utils.c
@@ -70,8 +70,7 @@ BAT *GDKval = NULL;
 #define VALGRIND_FREELIKE_BLOCK(addr, rzB)
 #endif
 
-static int GDKstopped = 1;
-static MT_Lock GDKstoppedLock;
+static volatile int GDKstopped = 1;
 static void GDKunlockHome(void);
 static int GDKgetHome(void);
 
@@ -346,9 +345,12 @@ volatile long GDK_nmallocs[MAX_BIT] = { 
 #define ATOMIC_SUB(var, val)   __sync_sub_and_fetch(&var, (long) (val))
 #define ATOMIC_DEC(var)                __sync_sub_and_fetch(&var, (long) 1)
 #endif
-#define ATOMIC_START(func)
-#define ATOMIC_END(func)
-#define ATOMIC_INIT(func)
+#define ATOMIC_START(lock, func)
+#define ATOMIC_END(lock, func)
+#define ATOMIC_INIT(lock, func)
+#define ATOMIC_COMP_SWAP(var, old, new, lock, func)    \
+       __sync_val_compare_and_swap(&var, old, new)
+#define ATOMIC_GET(var, lock, func)    var
 #elif defined(_MSC_VER)
 #include <intrin.h>
 #if SIZEOF_SSIZE_T == SIZEOF___INT64
@@ -384,9 +386,13 @@ volatile long GDK_nmallocs[MAX_BIT] = { 
 #pragma intrinsic(_InterlockedIncrement)
 #pragma intrinsic(_InterlockedDecrement)
 #endif
-#define ATOMIC_START(func)
-#define ATOMIC_END(func)
-#define ATOMIC_INIT(func)
+#define ATOMIC_START(lock, func)
+#define ATOMIC_END(lock, func)
+#define ATOMIC_INIT(lock, func)
+#define ATOMIC_COMP_SWAP(var, old, new, lock, func)    \
+       _InterlockedCompareExchange(&var, new, old)
+#pragma intrinsic(_InterlockedCompareExchange)
+#define ATOMIC_GET(var, lock, func)    var
 #else
 static volatile ssize_t GDK_mallocedbytes_estimate = 0;
 static volatile ssize_t GDK_vm_cursize = 0;
@@ -397,13 +403,37 @@ volatile ssize_t GDK_vm_nallocs[MAX_BIT]
 volatile ssize_t GDK_nmallocs[MAX_BIT] = { 0 };
 #endif
 static MT_Lock mbyteslock;
+static MT_Lock GDKstoppedLock;
 #define ATOMIC_ADD(var, val)   var += (ssize_t) (val)
 #define ATOMIC_INC(var)                var++
 #define ATOMIC_SUB(var, val)   var -= (ssize_t) (val)
 #define ATOMIC_DEC(var)                var--
-#define ATOMIC_START(func)     MT_lock_set(&mbyteslock, func)
-#define ATOMIC_END(func)       MT_lock_unset(&mbyteslock, func)
-#define ATOMIC_INIT(func)      MT_lock_init(&mbyteslock, func)
+#define ATOMIC_START(lock, func)       MT_lock_set(&lock, func)
+#define ATOMIC_END(lock, func) MT_lock_unset(&lock, func)
+#define ATOMIC_INIT(lock, func)        MT_lock_init(&lock, func)
+static inline int
+atomic_comp_swap(volatile int *var, int old, int new, MT_Lock *lock, const 
char *func)
+{
+       int orig;
+       MT_lock_set(lock, func);
+       orig = *var;
+       if (*var == old)
+               *var = new;
+       MT_lock_unset(lock, func);
+       return orig;
+}
+#define ATOMIC_COMP_SWAP(var, old, new, lock, func)    \
+       atomic_comp_swap(&var, old, new, &lock, func)
+static inline int
+atomic_get(volatile int *var, MT_Lock *lock, const char *func)
+{
+       int orig;
+       MT_lock_set(lock, func);
+       orig = *var;
+       MT_lock_unset(lock, func);
+       return orig;
+}
+#define ATOMIC_GET(var, lock, func)    atomic_get(&var, &lock, func)
 #endif
 
 size_t _MT_pagesize = 0;       /* variable holding memory size */
@@ -520,9 +550,9 @@ GDKmem_inuse(void)
        /* RAM/swapmem that Monet is really using now */
        size_t mem_mallocedbytes_estimate;
 
-       ATOMIC_START("GDKmem_inuse");
+       ATOMIC_START(mbyteslock, "GDKmem_inuse");
        mem_mallocedbytes_estimate = (size_t) GDK_mallocedbytes_estimate;
-       ATOMIC_END("GDKmem_inuse");
+       ATOMIC_END(mbyteslock, "GDKmem_inuse");
 
        return mem_mallocedbytes_estimate;
 }
@@ -533,9 +563,9 @@ GDKvm_cursize(void)
        /* current Monet VM address space usage */
        size_t vm_cursize;
 
-       ATOMIC_START("GDKvm_cursize");
+       ATOMIC_START(mbyteslock, "GDKvm_cursize");
        vm_cursize = (size_t) GDK_vm_cursize;
-       ATOMIC_END("GDKvm_cursize");
+       ATOMIC_END(mbyteslock, "GDKvm_cursize");
 
        return vm_cursize + GDKmem_inuse();
 }
@@ -545,36 +575,36 @@ GDKvm_cursize(void)
        do {                                                            \
                int _idx;                                               \
                                                                        \
-               ATOMIC_START("heapinc");                                \
+               ATOMIC_START(mbyteslock, "heapinc");                    \
                ATOMIC_ADD(GDK_mallocedbytes_estimate, _memdelta);      \
                GDKmallidx(_idx, _memdelta);                            \
                ATOMIC_INC(GDK_nmallocs[_idx]);                         \
-               ATOMIC_END("heapinc");                                  \
+               ATOMIC_END(mbyteslock, "heapinc");                      \
        } while (0)
 #define heapdec(memdelta)                                              \
        do {                                                            \
                ssize_t _memdelta = (ssize_t) (memdelta);               \
                int _idx;                                               \
                                                                        \
-               ATOMIC_START("heapdec");                                \
+               ATOMIC_START(mbyteslock, "heapdec");                    \
                ATOMIC_SUB(GDK_mallocedbytes_estimate, _memdelta);      \
                GDKmallidx(_idx, _memdelta);                            \
                ATOMIC_DEC(GDK_nmallocs[_idx]);                         \
-               ATOMIC_END("heapdec");                                  \
+               ATOMIC_END(mbyteslock, "heapdec");                      \
        } while (0)
 #else
 #define heapinc(_memdelta)                                             \
        do {                                                            \
-               ATOMIC_START("heapinc");                                \
+               ATOMIC_START(mbyteslock, "heapinc");                    \
                ATOMIC_ADD(GDK_mallocedbytes_estimate, _memdelta);      \
-               ATOMIC_END("heapinc");                                  \
+               ATOMIC_END(mbyteslock, "heapinc");                      \
        } while (0)
 #define heapdec(memdelta)                                              \
        do {                                                            \
                ssize_t _memdelta = (ssize_t) (memdelta);               \
-               ATOMIC_START("heapdec");                                \
+               ATOMIC_START(mbyteslock, "heapdec");                    \
                ATOMIC_SUB(GDK_mallocedbytes_estimate, _memdelta);      \
-               ATOMIC_END("heapdec");                                  \
+               ATOMIC_END(mbyteslock, "heapdec");                      \
        } while (0)
 #endif
 
@@ -584,39 +614,39 @@ GDKvm_cursize(void)
                ssize_t _vmdelta = (ssize_t) SEG_SIZE((vmdelta),MT_VMUNITLOG); \
                int _idx;                                               \
                                                                        \
-               ATOMIC_START(fcn);                                      \
+               ATOMIC_START(mbyteslock, fcn);                          \
                GDKmallidx(_idx, _vmdelta);                             \
                ATOMIC_INC(GDK_vm_nallocs[_idx]);                       \
                ATOMIC_ADD(GDK_vm_cursize, _vmdelta);                   \
-               ATOMIC_END(fcn);                                        \
+               ATOMIC_END(mbyteslock, fcn);                            \
        } while (0)
 #define memdec(vmdelta, fcn)                                           \
        do {                                                            \
                ssize_t _vmdelta = (ssize_t) SEG_SIZE((vmdelta),MT_VMUNITLOG); \
                int _idx;                                               \
                                                                        \
-               ATOMIC_START(fcn);                                      \
+               ATOMIC_START(mbyteslock, fcn);                          \
                GDKmallidx(_idx, _vmdelta);                             \
                ATOMIC_DEC(GDK_vm_nallocs[_idx]);                       \
                ATOMIC_SUB(GDK_vm_cursize, _vmdelta);                   \
-               ATOMIC_END(fcn);                                        \
+               ATOMIC_END(mbyteslock, fcn);                            \
        } while (0)
 #else
 #define meminc(vmdelta, fcn)                                           \
        do {                                                            \
                ssize_t _vmdelta = (ssize_t) SEG_SIZE((vmdelta),MT_VMUNITLOG); \
                                                                        \
-               ATOMIC_START(fcn);                                      \
+               ATOMIC_START(mbyteslock, fcn);                          \
                ATOMIC_ADD(GDK_vm_cursize, _vmdelta);                   \
-               ATOMIC_END(fcn);                                        \
+               ATOMIC_END(mbyteslock, fcn);                            \
        } while (0)
 #define memdec(vmdelta, fcn)                                           \
        do {                                                            \
                ssize_t _vmdelta = (ssize_t) SEG_SIZE((vmdelta),MT_VMUNITLOG); \
                                                                        \
-               ATOMIC_START(fcn);                                      \
+               ATOMIC_START(mbyteslock, fcn);                          \
                ATOMIC_SUB(GDK_vm_cursize, _vmdelta);                   \
-               ATOMIC_END(fcn);                                        \
+               ATOMIC_END(mbyteslock, fcn);                            \
        } while (0)
 #endif
 
@@ -640,28 +670,28 @@ GDKmemdump(void)
        {
                int i;
 
-               ATOMIC_START("GDKmemdump");
+               ATOMIC_START(mbyteslock, "GDKmemdump");
                THRprintf(GDKstdout, "#memory histogram\n");
                for (i = 3; i < GDK_HISTO_MAX_BIT - 1; i++) {
                        size_t j = 1 << i;
 
                        THRprintf(GDKstdout, "# " SZFMT " " SZFMT "\n", j, 
GDK_nmallocs[i]);
                }
-               ATOMIC_END("GDKmemdump");
+               ATOMIC_END(mbyteslock, "GDKmemdump");
        }
 #endif
 #ifdef GDK_VM_KEEPHISTO
        {
                int i;
 
-               ATOMIC_START("GDKmemdump");
+               ATOMIC_START(mbyteslock, "GDKmemdump");
                THRprintf(GDKstdout, "\n#virtual memory histogram\n");
                for (i = 12; i < GDK_HISTO_MAX_BIT - 1; i++) {
                        size_t j = 1 << i;
 
                        THRprintf(GDKstdout, "# " SZFMT " " SZFMT "\n", j, 
GDK_vm_nallocs[i]);
                }
-               ATOMIC_END("GDKmemdump");
+               ATOMIC_END(mbyteslock, "GDKmemdump");
        }
 #endif
 }
@@ -1071,7 +1101,7 @@ GDKinit(opt *set, int setlen)
 #ifndef PTHREAD_MUTEX_INITIALIZER
        MT_lock_init(&MT_system_lock,"GDKinit");
 #endif
-       MT_lock_init(&GDKstoppedLock, "GDKinit");
+       ATOMIC_INIT(GDKstoppedLock, "GDKinit");
        for (i = 0; i <= BBP_BATMASK; i++) {
                MT_lock_init(&GDKbatLock[i].swap, "GDKswapLock");
                MT_lock_init(&GDKbatLock[i].hash, "GDKhashLock");
@@ -1086,7 +1116,7 @@ GDKinit(opt *set, int setlen)
        MT_lock_init(&GDKunloadLock, "GDKunloadLock");
        MT_cond_init(&GDKunloadCond, "GDKunloadCond");
        MT_lock_init(&GDKtmLock, "GDKtmLock");
-       ATOMIC_INIT("mbyteslock");
+       ATOMIC_INIT(mbyteslock, "mbyteslock");
        errno = 0;
        if (!GDKenvironment(dbpath))
                return 0;
@@ -1227,12 +1257,7 @@ static int GDKnrofthreads;
 int
 GDKexiting(void)
 {
-       int stopped;
-
-       MT_lock_set(&GDKstoppedLock, "GDKexiting");
-       stopped = GDKstopped;
-       MT_lock_unset(&GDKstoppedLock, "GDKexiting");
-       return stopped;
+       return ATOMIC_GET(GDKstopped, GDKstoppedLock, "GDKexiting");
 }
 
 /* coverity[+kill] */
@@ -1240,10 +1265,7 @@ void
 GDKexit(int status)
 {
        MT_lock_set(&GDKthreadLock, "GDKexit");
-       MT_lock_set(&GDKstoppedLock, "GDKexit");
-       if (GDKstopped == 0) {
-               GDKstopped = 1;
-               MT_lock_unset(&GDKstoppedLock, "GDKexit");
+       if (ATOMIC_COMP_SWAP(GDKstopped, 0, 1, GDKstoppedLock, "GDKexit") == 0) 
{
                if (GDKvmtrim_id)
                        MT_join_thread(GDKvmtrim_id);
                GDKnrofthreads = 0;
@@ -1272,8 +1294,6 @@ GDKexit(int status)
                GDKlog(GDKLOGOFF);
                GDKunlockHome();
                MT_global_exit(status);
-       } else {
-               MT_lock_unset(&GDKstoppedLock, "GDKexit");
        }
        MT_lock_unset(&GDKthreadLock, "GDKexit");
 }
_______________________________________________
checkin-list mailing list
[email protected]
http://mail.monetdb.org/mailman/listinfo/checkin-list

Reply via email to