Changeset: 9c14fb4f6e18 for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=9c14fb4f6e18
Modified Files:
gdk/gdk_atomic.h
gdk/gdk_bat.c
gdk/gdk_mapreduce.c
gdk/gdk_utils.c
monetdb5/mal/mal_resource.c
monetdb5/mal/mal_runtime.c
Branch: default
Log Message:
Merge with Feb2013 branch.
diffs (truncated from 849 to 300 lines):
diff --git a/gdk/gdk_atomic.h b/gdk/gdk_atomic.h
--- a/gdk/gdk_atomic.h
+++ b/gdk/gdk_atomic.h
@@ -17,86 +17,365 @@
* All Rights Reserved.
*/
+/* This file provides interfaces to perform certain atomic operations
+ * on variables. Atomic in this sense means that an operation
+ * performed in one thread shows up in another thread either
+ * completely or not at all.
+ *
+ * If the symbol ATOMIC_LOCK is defined, a variable of type MT_Lock
+ * must be declared and initialized. The latter can be done using the
+ * macro ATOMIC_INIT which expands to nothing if ATOMIC_LOCK is not
+ * defined.
+ *
+ * The following operations are defined:
+ * ATOMIC_GET -- return the value of a variable;
+ * ATOMIC_SET -- set the value of a variable;
+ * ATOMIC_ADD -- add a value to a variable, return original value;
+ * ATOMIC_SUB -- subtract a value from a variable, return original value;
+ * ATOMIC_INT -- increment a variable's value, return new value;
+ * ATOMIC_DEC -- decrement a variable's value, return new value;
+ * ATOMIC_CAS -- compare-and-set: compare the variable's value with
+ * old and if it matches, replace with new, return
+ * original value.
+ * As written, these interfaces work on variables of type ATOMIC_TYPE
+ * (int or lng depending on architecture). There are also versions of
+ * these interfaces specifically for int, and on 64-bit architectures,
+ * for lng. In addition, all but add and sub are also defined for sht
+ * (Windows restriction). To get the type-specific interface, append
+ * _sht, _int, or _lng to the above names.
+ */
+
#ifndef _GDK_ATOMIC_H_
#define _GDK_ATOMIC_H_
#if defined(_MSC_VER)
+
#include <intrin.h>
-#if SIZEOF_SSIZE_T == SIZEOF___INT64
-#define ATOMIC_TYPE __int64
-#define ATOMIC_ADD(var, val) _InterlockedExchangeAdd64(&var, (__int64) (val))
-#define ATOMIC_INC(var) _InterlockedIncrement64(&var)
-#define ATOMIC_SUB(var, val) _InterlockedExchangeAdd64(&var, -(__int64)
(val))
-#define ATOMIC_DEC(var) _InterlockedDecrement64(&var)
+
+#define ATOMIC_GET_sht(var, lck, fcn) var
+#define ATOMIC_SET_sht(var, val, lck, fcn) (var = (val))
+#define ATOMIC_INC_sht(var, lck, fcn) _InterlockedIncrement16(&var)
+#define ATOMIC_DEC_sht(var, lck, fcn) _InterlockedDecrement16(&var)
+#define ATOMIC_CAS_sht(var, old, new, lck, fcn)
_InterlockedCompareExchange16(&var, new, old)
+
+#pragma intrinsic(_InterlockedIncrement16)
+#pragma intrinsic(_InterlockedDecrement16)
+#pragma intrinsic(_InterlockedCompareExchange16)
+
+#define ATOMIC_GET_int(var, lck, fcn) var
+#define ATOMIC_SET_int(var, val, lck, fcn) (var = (val))
+#define ATOMIC_ADD_int(var, val, lck, fcn) _InterlockedExchangeAdd(&var,
(val))
+#define ATOMIC_SUB_int(var, val, lck, fcn) _InterlockedExchangeAdd(&var,
-(val))
+#define ATOMIC_INC_int(var, lck, fcn) _InterlockedIncrement(&var)
+#define ATOMIC_DEC_int(var, lck, fcn) _InterlockedDecrement(&var)
+#define ATOMIC_CAS_int(var, old, new, lck, fcn)
_InterlockedCompareExchange(&var, new, old)
+
+#pragma intrinsic(_InterlockedExchangeAdd)
+#pragma intrinsic(_InterlockedIncrement)
+#pragma intrinsic(_InterlockedDecrement)
+#pragma intrinsic(_InterlockedCompareExchange)
+
+#if SIZEOF_SSIZE_T == SIZEOF_LNG
+#define ATOMIC_GET_lng(var, lck, fcn) var
+#define ATOMIC_SET_lng(var, val, lck, fcn) (var = (val))
+#define ATOMIC_ADD_lng(var, val, lck, fcn) _InterlockedExchangeAdd64(&var,
val)
+#define ATOMIC_SUB_lng(var, val, lck, fcn) _InterlockedExchangeAdd64(&var,
-(val))
+#define ATOMIC_INC_lng(var, lck, fcn) _InterlockedIncrement64(&var)
+#define ATOMIC_DEC_lng(var, lck, fcn) _InterlockedDecrement64(&var)
+#define ATOMIC_CAS_lng(var, old, new, lck, fcn)
_InterlockedCompareExchange64(&var, new, old)
+
#pragma intrinsic(_InterlockedExchangeAdd64)
#pragma intrinsic(_InterlockedIncrement64)
#pragma intrinsic(_InterlockedDecrement64)
+#pragma intrinsic(_InterlockedCompareExchange64)
+#endif
+
+#define ATOMIC_INIT(lck, fcn) ((void) 0)
+
+#elif defined(__GNUC__) || defined(__INTEL_COMPILER)
+
+#define ATOMIC_GET_sht(var, lck, fcn) var
+#define ATOMIC_SET_sht(var, val, lck, fcn) (var = (val))
+#define ATOMIC_INC_sht(var, lck, fcn) __sync_add_and_fetch(&var, 1)
+#define ATOMIC_DEC_sht(var, lck, fcn) __sync_sub_and_fetch(&var, 1)
+#define ATOMIC_CAS_sht(var, old, new, lck, fcn)
__sync_val_compare_and_swap(&var, old, new)
+
+#define ATOMIC_GET_int(var, lck, fcn) var
+#define ATOMIC_SET_int(var, val, lck, fcn) (var = (val))
+#define ATOMIC_ADD_int(var, val, lck, fcn) __sync_fetch_and_add(&var,
(val))
+#define ATOMIC_SUB_int(var, val, lck, fcn) __sync_fetch_and_sub(&var,
(val))
+#define ATOMIC_INC_int(var, lck, fcn) __sync_add_and_fetch(&var, 1)
+#define ATOMIC_DEC_int(var, lck, fcn) __sync_sub_and_fetch(&var, 1)
+#define ATOMIC_CAS_int(var, old, new, lck, fcn)
__sync_val_compare_and_swap(&var, old, new)
+
+#if SIZEOF_SSIZE_T == SIZEOF_LNG
+#define ATOMIC_GET_lng(var, lck, fcn) var
+#define ATOMIC_SET_lng(var, val, lck, fcn) (var = (val))
+#define ATOMIC_ADD_lng(var, val, lck, fcn) __sync_fetch_and_add(&var,
(val))
+#define ATOMIC_SUB_lng(var, val, lck, fcn) __sync_fetch_and_sub(&var,
(val))
+#define ATOMIC_INC_lng(var, lck, fcn) __sync_add_and_fetch(&var, 1)
+#define ATOMIC_DEC_lng(var, lck, fcn) __sync_sub_and_fetch(&var, 1)
+#define ATOMIC_CAS_lng(var, old, new, lck, fcn)
__sync_val_compare_and_swap(&var, old, new)
+#endif
+
+#define ATOMIC_INIT(lck, fcn) ((void) 0)
+
#else
-#define ATOMIC_TYPE long
-#define ATOMIC_ADD(var, val) _InterlockedExchangeAdd(&var, (long) (val))
-#define ATOMIC_INC(var) _InterlockedIncrement(&var)
-#define ATOMIC_SUB(var, val) _InterlockedExchangeAdd(&var, -(long) (val))
-#define ATOMIC_DEC(var) _InterlockedDecrement(&var)
-#pragma intrinsic(_InterlockedExchangeAdd)
-#pragma intrinsic(_InterlockedIncrement)
-#pragma intrinsic(_InterlockedDecrement)
-#endif
-#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
-#elif defined(__GNUC__) || defined(__INTEL_COMPILER)
-#if SIZEOF_SSIZE_T == SIZEOF_LONG_LONG
-#define ATOMIC_TYPE long long
-#else
-#define ATOMIC_TYPE long
-#endif
-#define ATOMIC_ADD(var, val) __sync_fetch_and_add(&var, (ATOMIC_TYPE) (val))
-#define ATOMIC_INC(var) __sync_add_and_fetch(&var,
(ATOMIC_TYPE) 1)
-#define ATOMIC_SUB(var, val) __sync_fetch_and_sub(&var, (ATOMIC_TYPE) (val))
-#define ATOMIC_DEC(var) __sync_sub_and_fetch(&var,
(ATOMIC_TYPE) 1)
-#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
-#else
-#define ATOMIC_LOCK PTHREAD_MUTEX_INITIALIZER /* must use locks */
-#define ATOMIC_TYPE ssize_t
-#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(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)
+
+static inline sht
+__ATOMIC_GET_sht(volatile sht *var, MT_Lock *lck, const char *fcn)
{
- int orig;
- MT_lock_set(lock, func);
+ sht old;
+ MT_lock_set(lck, fcn);
+ old = *var;
+ MT_lock_unset(lck, fcn);
+ return old;
+}
+#define ATOMIC_GET_sht(var, lck, fcn) __ATOMIC_GET_sht(&var, &lck, fcn)
+
+static inline sht
+__ATOMIC_SET_sht(volatile sht *var, sht val, MT_Lock *lck, const char *fcn)
+{
+ sht new;
+ MT_lock_set(lck, fcn);
+ *var = val;
+ new = *var;
+ MT_lock_unset(lck, fcn);
+ return new;
+}
+#define ATOMIC_SET_sht(var, val, lck, fcn) __ATOMIC_SET_sht(&var, (val),
&lck, fcn)
+
+static inline sht
+__ATOMIC_INC_sht(volatile sht *var, MT_Lock *lck, const char *fcn)
+{
+ sht new;
+ MT_lock_set(lck, fcn);
+ new = ++*var;
+ MT_lock_unset(lck, fcn);
+ return new;
+}
+#define ATOMIC_INC_sht(var, lck, fcn) __ATOMIC_INC_sht(&var, &lck,
fcn)
+
+static inline sht
+__ATOMIC_DEC_sht(volatile sht *var, MT_Lock *lck, const char *fcn)
+{
+ sht new;
+ MT_lock_set(lck, fcn);
+ new = --*var;
+ MT_lock_unset(lck, fcn);
+ return new;
+}
+#define ATOMIC_DEC_sht(var, lck, fcn) __ATOMIC_DEC_sht(&var, &lck,
fcn)
+
+static inline sht
+__ATOMIC_CAS_sht(volatile sht *var, sht old, sht new, MT_Lock *lck, const char
*fcn)
+{
+ sht orig;
+ MT_lock_set(lck, fcn);
orig = *var;
if (*var == old)
*var = new;
- MT_lock_unset(lock, func);
+ MT_lock_unset(lck, fcn);
return orig;
}
-#define ATOMIC_COMP_SWAP(var, old, new, lock, func) \
- atomic_comp_swap(&var, old, new, &lock, func)
+#define ATOMIC_CAS_sht(var, old, new, lck, fcn) __ATOMIC_CAS_sht(&var,
(old), (new), &lck, fcn)
+
+
static inline int
-atomic_get(volatile int *var, MT_Lock *lock, const char *func)
+__ATOMIC_GET_int(volatile int *var, MT_Lock *lck, const char *fcn)
+{
+ int old;
+ MT_lock_set(lck, fcn);
+ old = *var;
+ MT_lock_unset(lck, fcn);
+ return old;
+}
+#define ATOMIC_GET_int(var, lck, fcn) __ATOMIC_GET_int(&var, &lck, fcn)
+
+static inline int
+__ATOMIC_SET_int(volatile int *var, int val, MT_Lock *lck, const char *fcn)
+{
+ int new;
+ MT_lock_set(lck, fcn);
+ *var = val;
+ new = *var;
+ MT_lock_unset(lck, fcn);
+ return new;
+}
+#define ATOMIC_SET_int(var, val, lck, fcn) __ATOMIC_SET_int(&var, (val),
&lck, fcn)
+
+static inline int
+__ATOMIC_ADD_int(volatile int *var, int val, MT_Lock *lck, const char *fcn)
+{
+ int old;
+ MT_lock_set(lck, fcn);
+ old = *var;
+ *var += val;
+ MT_lock_unset(lck, fcn);
+ return old;
+}
+#define ATOMIC_ADD_int(var, val, lck, fcn) __ATOMIC_ADD_int(&var, (val),
&lck, fcn)
+
+static inline int
+__ATOMIC_SUB_int(volatile int *var, int val, MT_Lock *lck, const char *fcn)
+{
+ int old;
+ MT_lock_set(lck, fcn);
+ old = *var;
+ *var -= val;
+ MT_lock_unset(lck, fcn);
+ return old;
+}
+#define ATOMIC_SUB_int(var, val, lck, fcn) __ATOMIC_SUB_int(&var, (val),
&lck, fcn)
+
+static inline int
+__ATOMIC_INC_int(volatile int *var, MT_Lock *lck, const char *fcn)
+{
+ int new;
+ MT_lock_set(lck, fcn);
+ new = ++*var;
+ MT_lock_unset(lck, fcn);
+ return new;
+}
+#define ATOMIC_INC_int(var, lck, fcn) __ATOMIC_INC_int(&var, &lck,
fcn)
+
+static inline int
+__ATOMIC_DEC_int(volatile int *var, MT_Lock *lck, const char *fcn)
+{
+ int new;
+ MT_lock_set(lck, fcn);
+ new = --*var;
+ MT_lock_unset(lck, fcn);
+ return new;
+}
+#define ATOMIC_DEC_int(var, lck, fcn) __ATOMIC_DEC_int(&var, &lck,
fcn)
+
+static inline int
+__ATOMIC_CAS_int(volatile int *var, int old, int new, MT_Lock *lck, const char
*fcn)
{
int orig;
_______________________________________________
checkin-list mailing list
[email protected]
http://mail.monetdb.org/mailman/listinfo/checkin-list
