PR123: LD_LIBRARY_PATH and java.library.path

[cacao.git] / src / threads / atomic.hpp

diff --git a/src/threads/atomic.hpp b/src/threads/atomic.hpp
index 10937138d686f3af26076b55857d2b938d3f9f54..a3875d632921b9df564603fd7568c680155a75b3 100644 (file)
--- a/src/threads/atomic.hpp
+++ b/src/threads/atomic.hpp
@@ -30,15 +30,90 @@
 
 #include <stdint.h>
 
-uint32_t Atomic_generic_compare_and_swap_32(volatile uint32_t *p, uint32_t oldval, uint32_t newval);
-uint64_t Atomic_generic_compare_and_swap_64(volatile uint64_t *p, uint64_t oldval, uint64_t newval);
-void*    Atomic_generic_compare_and_swap_ptr(volatile void** p, void* oldval, void* newval);
-void     Atomic_generic_memory_barrier(void);
+#ifdef __cplusplus
+
+namespace Atomic_md {
+       // Machine dependent functions.
+       uint32_t compare_and_swap(volatile uint32_t *p, uint32_t oldval, uint32_t newval);
+       uint64_t compare_and_swap(volatile uint64_t *p, uint64_t oldval, uint64_t newval);
+
+       void     memory_barrier(void);
+       void     write_memory_barrier(void);
+       void     instruction_barrier(void);
+}
+
+namespace Atomic {
+
+       // Generic functions.
+       uint32_t generic_compare_and_swap(volatile uint32_t *p, uint32_t oldval, uint32_t newval);
+       uint64_t generic_compare_and_swap(volatile uint64_t *p, uint64_t oldval, uint64_t newval);
+       void*    generic_compare_and_swap(volatile void** p, void* oldval, void* newval);
+       void     generic_memory_barrier(void);
+
+}
 
 // Include machine dependent implementation.
 #include "md-atomic.hpp"
 
-#endif /* _ATOMIC_HPP */
+namespace Atomic {
+
+       struct CAS_32_functor {
+               typedef uint32_t value_type;
+               static value_type compare_and_swap(value_type *p, value_type o, value_type n) {
+                       return Atomic_md::compare_and_swap(p, o, n);
+               }
+       };
+
+       struct CAS_64_functor {
+               typedef uint64_t value_type;
+               static value_type compare_and_swap(value_type *p, value_type o, value_type n) {
+                       return Atomic_md::compare_and_swap(p, o, n);
+               }
+       };
+
+       template<int N> class CAS_chooser;
+       template<> class CAS_chooser<4> {
+               public:
+                       typedef CAS_32_functor the_type;
+       };
+       template<> class CAS_chooser<8> {
+               public:
+                       typedef CAS_64_functor the_type;
+       };
+
+       template<class T> class CAS {
+               public:
+                       typedef typename CAS_chooser<sizeof(T)>::the_type S;
+                       static T compare_and_swap(T *p, T o, T n) {
+                               return (T) S::compare_and_swap((typename S::value_type*) p,
+                                               (typename S::value_type) o,
+                                               (typename S::value_type) n);
+                       }
+       };
+
+       template<class T> T compare_and_swap(T *p, T o, T n) {
+               return CAS<T>::compare_and_swap(p, o, n);
+       }
+
+       inline void     memory_barrier(void)       { Atomic_md::memory_barrier(); }
+       inline void     write_memory_barrier(void) { Atomic_md::write_memory_barrier(); }
+       inline void     instruction_barrier(void)  { Atomic_md::instruction_barrier(); }
+}
+
+#else
+
+// Legacy C interface.
+
+uint32_t Atomic_compare_and_swap_32(uint32_t *p, uint32_t oldval, uint32_t newval);
+uint64_t Atomic_compare_and_swap_64(uint64_t *p, uint64_t oldval, uint64_t newval);
+void*    Atomic_compare_and_swap_ptr(void** p, void* oldval, void* newval);
+void     Atomic_memory_barrier(void);
+void     Atomic_write_memory_barrier(void);
+void     Atomic_instruction_barrier(void);
+
+#endif
+
+#endif // _ATOMIC_HPP
 
 
 /*