atomic ops routed via qt
authorapg <apg@76c9efe7-43af-4aca-a270-d8da3bf5252a>
Wed, 17 Feb 2010 18:38:04 +0000 (18:38 +0000)
committerapg <apg@76c9efe7-43af-4aca-a270-d8da3bf5252a>
Wed, 17 Feb 2010 18:38:04 +0000 (18:38 +0000)
git-svn-id: svn://oss.syntext.com/oss/serna-free/trunk@282 76c9efe7-43af-4aca-a270-d8da3bf5252a

sfworks/common/RefCounted.h
sfworks/common/ThreadMutex.h
sfworks/common/ThreadingPolicies.h
sfworks/common/impl/ThreadMutex.cxx

index 7870c1d..aef6092 100644 (file)
 // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 // 
-/*! \file
-    Implementation of RefCounted
- */
 #ifndef REF_COUNTED_H
 #define REF_COUNTED_H
 
 #include "common/common_defs.h"
 #include "common/ThreadingPolicies.h"
 
-
-COMMON_NS_BEGIN
+namespace Common {
 
 /*! Objects eligible for intrusive refcounting should inherit from
     this class.
@@ -47,31 +43,20 @@ template <class TP = DEFAULT_THREADING<> >
 class RefCounted {
 public:
     /// Decrement reference counter & return new value
-    int32 decRefCnt() const
-    {
-        return TP::atomicDecrement(count_);
-    }
+    int32 decRefCnt() const { count_.deref(); return count_; }
 
     /// Increment reference counter
-    void incRefCnt() const
-    {
-        TP::atomicIncrement(count_);
-    }
+    void incRefCnt() const { count_.ref(); }
 
     /// Return ref counter's value
-    int32 getRefCnt() const
-    {
-        return TP::atomicRead(count_);
-    }
+    int32 getRefCnt() const { return count_; }
 
-    RefCounted() : count_(0) {}
     RefCounted(const RefCounted&) : count_(0) {}
-    ~RefCounted() {}
-
+    RefCounted() : count_(0) {}
+    
 private:
-    typedef typename TP::VolatileIntType CounterType;
-
-    mutable CounterType count_; ///< The actual reference counter
+    typedef typename TP::AtomicInt AtomicInt;
+    mutable AtomicInt count_;
 };
 
 #ifdef _WIN32
@@ -88,6 +73,6 @@ template class COMMON_EXPIMP RefCounted<>;
 template <class BT, class TP = DEFAULT_THREADING<> >
   class RefCountedBase : public BT, public RefCounted<TP> {};
 
-COMMON_NS_END
+} // namespace Common
 
 #endif // REF_COUNTED_H
index c5b0d5b..5d9081a 100644 (file)
@@ -43,6 +43,7 @@
 #include "common/common_defs.h"
 #include "common/common_types.h"
 
+#include <QBasicAtomicInt>
 
 #ifdef MULTI_THREADED
 # ifdef _WIN32
@@ -59,6 +60,7 @@
 
 COMMON_NS_BEGIN
 
+
 /*! A null mutex (no multithreading)
  */
 class COMMON_EXPIMP NullThreadMutex {
@@ -95,28 +97,6 @@ public:
         assert(m->initialized_); assert(m->locked_); m->locked_ = false;
     }
 #endif // MUTEX_DEBUG
-    static IntType atomicIncrement(VolatileIntType& lval)
-    {
-        return ++lval;
-    }
-    static IntType atomicDecrement(VolatileIntType& lval)
-    {
-        return --lval;
-    }
-    static IntType atomicRead(VolatileIntType& lval)
-    {
-        return lval;
-    }
-    static void    atomicAssign(VolatileIntType& lval, IntType rval)
-    {
-        lval = rval;
-    }
-    static IntType atomicExchange(VolatileIntType& lval, IntType rval)
-    {
-        IntType tmp = lval;
-        lval = rval;
-        return tmp;
-    }
 #ifdef MUTEX_DEBUG
 private:
     bool locked_;
@@ -125,7 +105,6 @@ private:
 };
 
 #ifdef MULTI_THREADED
-
 /*! Non-recursive thread mutex
  */
 class COMMON_EXPIMP ThreadMutex {
@@ -138,18 +117,11 @@ public:
     // posix threads mutexes
     typedef ::pthread_mutex_t MutexType;
 # endif
-    typedef volatile IntType VolatileIntType;
 
     static void initialize(MutexType*);
     static void destroy(MutexType*);
     static void lock(MutexType*);
     static void unlock(MutexType*);
-
-    static IntType atomicIncrement(VolatileIntType& lval);
-    static IntType atomicDecrement(VolatileIntType& lval);
-    static IntType atomicRead(VolatileIntType& lval);
-    static void    atomicAssign(VolatileIntType& lval, IntType rval);
-    static IntType atomicExchange(VolatileIntType& lval, IntType rval);
 };
 
 #else // MULTI_THREADED
@@ -160,13 +132,4 @@ class COMMON_EXPIMP ThreadMutex : public NullThreadMutex {};
 
 COMMON_NS_END
 
-#if defined(NDEBUG) && !defined(_DEBUG)
-# ifdef INLINE_ATOMICS
-#  undef INLINE_ATOMICS
-# endif
-# define INLINE_ATOMICS inline
-# include "machdep/ThreadMutexAtomics.i"
-# undef INLINE_ATOMICS
-#endif
-
 #endif // THREAD_MUTEX_H_
index f7076b7..6bdf824 100644 (file)
@@ -40,7 +40,7 @@
 
 #include "common/common_defs.h"
 #include "common/ThreadMutex.h"
-
+#include <QAtomicInt>
 
 // Specifies default threading model
 
 
 COMMON_NS_BEGIN
 
-// This is not a template because certain compilers have problem
-// with empty base optimization.
-#define ATOMIC_OPS_FORWARDERS__ \
-    typedef typename M::IntType         IntType; \
-    typedef typename M::VolatileIntType VolatileIntType; \
-    typedef typename M::MutexType       MutexType; \
-    \
-    typedef M ThreadMutexClass; \
-    \
-    static IntType atomicIncrement(VolatileIntType& lval) { \
-        return M::atomicIncrement(lval); \
-    } \
-    static IntType atomicDecrement(VolatileIntType& lval) { \
-        return M::atomicDecrement(lval); \
-    } \
-    static IntType atomicRead(VolatileIntType& lval) { \
-        return M::atomicRead(lval); \
-    } \
-    static void    atomicAssign(VolatileIntType& lval, IntType rval) { \
-        M::atomicAssign(lval, rval); \
-    }
+class ThreadAtomicInt : public QAtomicInt {
+public:
+    ThreadAtomicInt(int v) : QAtomicInt(v) {}
+    ThreadAtomicInt() {}
+};
 
 /*! Implementation of the SingleThreaded (no-synchronization) ThreadingModel
     policy used by various classes.
@@ -93,7 +77,10 @@ COMMON_NS_BEGIN
 template <class M = NullThreadMutex>
   class SingleThreaded {
 public:
-    ATOMIC_OPS_FORWARDERS__;
+    typedef ThreadAtomicInt AtomicInt; // no need for non-threaded now
+    typedef typename M::MutexType MutexType;
+    typedef M ThreadMutexClass;
+
     enum { multiThreaded = false }; // not really multithreaded
 
     /*! A lock guard primitive
@@ -115,7 +102,10 @@ public:
 template <class M = ThreadMutex>
   class ObjectLevelLockable {
 public:
-    ATOMIC_OPS_FORWARDERS__;
+    typedef ThreadAtomicInt AtomicInt;
+    typedef typename M::MutexType MutexType;
+    typedef M ThreadMutexClass;
+
     enum { multiThreaded = true };
 
     ObjectLevelLockable() {
@@ -155,7 +145,10 @@ private:
 template <class M = ThreadMutex>
   class ClassLevelLockable {
 public:
-    ATOMIC_OPS_FORWARDERS__;
+    typedef ThreadAtomicInt AtomicInt;
+    typedef typename M::MutexType MutexType;
+    typedef M ThreadMutexClass;
+    
     enum { multiThreaded = true };
 
     class Lock;
@@ -219,8 +212,6 @@ template <class M> bool ClassLevelLockable<M>::initialized_ = false;
 template <class M> typename ClassLevelLockable<M>::Initializer
     ClassLevelLockable<M>::initializer_;
 
-#undef ATOMIC_OPS_FORWARDERS__
-
 COMMON_NS_END
 
 #endif // THREADING_POLICIES_H_
index c1500ab..2696c58 100644 (file)
 // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 // 
-/** \file
- *  Implementation file for ThreadMutex.h
- */
-
-#if !defined(__i386__) && !defined(__sun) && \
-    !defined(_WIN32) && !defined(__APPLE__) && !defined(__amd64__)
-# error Atomic increment/decrement is not defined for your architecture
-#endif
-
 #include "common/common_defs.h"
 
 #ifdef MULTI_THREADED
@@ -117,7 +108,7 @@ void ThreadMutex::unlock(MutexType* m)
 
 COMMON_NS_END
 
-#if !defined(INLINE_ATOMICS)
+#if !defined(INLINE_ATOMICS) && defined(NO_QT_THREADING)
 # define INLINE_ATOMICS
 # include "machdep/ThreadMutexAtomics.i"
 #endif