add eina barrier stuff.

git-svn-id: http://svn.enlightenment.org/svn/e/trunk/eina@78099 7cbeb6ba-43b4-40fd-8cce-4c39aea84d33

diff --git a/configure.ac b/configure.ac
index 1011bec..a548ff7 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -104,7 +104,11 @@ EFL_CHECK_THREADS
 if ! test "x${efl_have_threads}" = "xno" ; then
    EINA_CONFIGURE_HAVE_THREADS="#define EINA_HAVE_THREADS"
 fi
+if ! test "x${efl_have_pthread_barrier}" = "xno" ; then
+   EINA_CONFIGURE_HAVE_PTHREAD_BARRIER="#define EINA_HAVE_PTHREAD_BARRIER"
+fi
 AC_SUBST(EINA_CONFIGURE_HAVE_THREADS)
+AC_SUBST(EINA_CONFIGURE_HAVE_PTHREAD_BARRIER)
 AM_CONDITIONAL([EINA_HAVE_THREADS], [! test "x${efl_have_threads}" = "xno"])
 
 if test "x${efl_have_debug_threads}" = "xyes"; then
@@ -616,6 +620,7 @@ echo "  Log support..........: ${enable_log}"
 echo "  Thread Support.......: ${efl_have_threads}"
 if test "${efl_have_threads}" = "POSIX" ; then
 echo "    spinlock...........: ${efl_have_posix_threads_spinlock}"
+echo "    barrier............: ${efl_have_pthread_barrier}"
 echo "    debug usage........: ${efl_have_debug_threads}"
 echo "    on/off support.....: ${efl_have_on_off_threads}"
 fi

diff --git a/m4/common/efl_threads.m4 b/m4/common/efl_threads.m4
index ae29606..a4ff98a 100644 (file)
--- a/m4/common/efl_threads.m4
+++ b/m4/common/efl_threads.m4
@@ -64,6 +64,16 @@ id = pthread_self();
        EFL_PTHREAD_LIBS=${_efl_threads_libs}
       ],
       [_efl_have_posix_threads="no"])
+   AC_LINK_IFELSE(
+      [AC_LANG_PROGRAM([[
+#include <pthread.h>
+                       ]],
+                       [[
+pthread_barrier_t barrier;
+pthread_barrier_init(&barrier, NULL, 1);
+                       ]])],
+      [efl_have_pthread_barrier="yes"],
+      [efl_have_pthread_barrier="no"])
    CFLAGS=${SAVE_CFLAGS}
    LIBS=${SAVE_LIBS}
 
@@ -75,8 +85,10 @@ if test "x${_efl_have_posix_threads}" = "xyes" ; then
 else
    if test "x${_efl_have_win32_threads}" = "xyes" ; then
       efl_have_threads="Windows"
+      efl_have_pthread_barrier="no"
    else
       efl_have_threads="no"
+      efl_have_pthread_barrier="no"
    fi
 fi
 AC_MSG_RESULT([${efl_have_threads}])

diff --git a/src/include/Makefile.am b/src/include/Makefile.am
index ba64e38..2bc629f 100644 (file)
--- a/src/include/Makefile.am
+++ b/src/include/Makefile.am
@@ -64,7 +64,8 @@ eina_refcount.h \
 eina_mmap.h \
 eina_xattr.h \
 eina_value.h \
-eina_inline_value.x
+eina_inline_value.x \
+eina_inline_lock_barrier.x
 
 # Will be back for developper after 1.2.
 # eina_model.h

diff --git a/src/include/eina_config.h.in b/src/include/eina_config.h.in
index 937d208..681fc17 100644 (file)
--- a/src/include/eina_config.h.in
+++ b/src/include/eina_config.h.in
@@ -58,6 +58,11 @@
 #endif
 @EINA_CONFIGURE_HAVE_THREADS@
 
+#ifdef EINA_HAVE_PTHREAD_BARRIER
+# undef EINA_HAVE_PTHREAD_BARRIER
+#endif
+@EINA_CONFIGURE_HAVE_PTHREAD_BARRIER@
+
 #ifdef EINA_HAVE_DEBUG_THREADS
 # undef EINA_HAVE_DEBUG_THREADS
 #endif

diff --git a/src/include/eina_inline_lock_barrier.x b/src/include/eina_inline_lock_barrier.x
new file mode 100644 (file)
index 0000000..536e26c
--- /dev/null
+++ b/src/include/eina_inline_lock_barrier.x
@@ -0,0 +1,48 @@
+typedef struct _Eina_Barrier Eina_Barrier;
+
+struct _Eina_Barrier
+{
+   int needed, called;
+   Eina_Lock lock, cond_lock;
+   Eina_Condition cond;
+};
+
+static inline Eina_Bool
+eina_barrier_new(Eina_Barrier *barrier, int needed)
+{
+   barrier->needed = needed;
+   barrier->called = 0;
+   if (!eina_lock_new(&(barrier->lock)))
+     return EINA_FALSE;
+   if (!eina_lock_new(&(barrier->cond_lock)))
+     return EINA_FALSE;
+   if (!eina_condition_new(&(barrier->cond), &(barrier->cond_lock)))
+     return EINA_FALSE;
+   return EINA_TRUE;
+}
+
+static inline void
+eina_barrier_free(Eina_Barrier *barrier)
+{
+   eina_condition_free(&(barrier->cond));
+   eina_lock_free(&(barrier->cond_lock));
+   eina_lock_free(&(barrier->lock));
+   barrier->needed = 0;
+   barrier->called = 0;
+}
+
+static inline Eina_Bool
+eina_barrier_wait(Eina_Barrier *barrier)
+{
+   eina_lock_take(&(barrier->lock));
+   barrier->called++;
+   if (barrier->called == barrier->needed)
+     {
+        barrier->called = 0;
+        eina_condition_broadcast(&(barrier->cond));
+     }
+   else
+     eina_condition_wait(&(barrier->cond));
+   eina_lock_release(&(barrier->lock));
+   return EINA_TRUE;
+}

diff --git a/src/include/eina_inline_lock_posix.x b/src/include/eina_inline_lock_posix.x
index 86cf1f7..88c4b61 100644 (file)
--- a/src/include/eina_inline_lock_posix.x
+++ b/src/include/eina_inline_lock_posix.x
@@ -544,4 +544,38 @@ eina_semaphore_release(Eina_Semaphore *sem, int count_release EINA_UNUSED)
    return (sem_post(sem) == 0) ? EINA_TRUE : EINA_FALSE;
 }
 
+#ifdef EINA_HAVE_PTHREAD_BARRIER
+typedef struct _Eina_Barrier Eina_Barrier;
+
+struct _Eina_Barrier
+{
+   pthread_barrier_t barrier;
+};
+
+static inline Eina_Bool
+eina_barrier_new(Eina_Barrier *barrier, int needed)
+{
+   if (!pthread_barrier_init(&(barrier->barrier), NULL, needed))
+     return EINA_TRUE;
+   return EINA_FALSE;
+}
+
+static inline void
+eina_barrier_free(Eina_Barrier *barrier)
+{
+   pthread_barrier_destroy(&(barrier->barrier));
+}
+
+static inline Eina_Bool
+eina_barrier_wait(Eina_Barrier *barrier)
+{
+   pthread_barrier_wait(&(barrier->barrier));
+   return EINA_TRUE;
+}
+
+#else
+#include "eina_inline_lock_barrier.x"
+#endif
+
+
 #endif

diff --git a/src/include/eina_inline_lock_void.x b/src/include/eina_inline_lock_void.x
index 1d1b5d4..ec552c6 100644 (file)
--- a/src/include/eina_inline_lock_void.x
+++ b/src/include/eina_inline_lock_void.x
@@ -257,6 +257,8 @@ eina_semaphore_release(Eina_Semaphore *sem EINA_UNUSED,
    return EINA_TRUE;
 }
 
+#include "eina_inline_lock_barrier.x"
+
 /**
  * @}
  */

diff --git a/src/include/eina_inline_lock_win32.x b/src/include/eina_inline_lock_win32.x
index 856f972..383a543 100644 (file)
--- a/src/include/eina_inline_lock_win32.x
+++ b/src/include/eina_inline_lock_win32.x
@@ -551,4 +551,6 @@ eina_semaphore_release(Eina_Semaphore *sem, int count_release)
    return ReleaseSemaphore(*sem, count_release, NULL) ? EINA_TRUE : EINA_FALSE;
 }
 
+#include "eina_inline_lock_barrier.x"
+
 #endif

diff --git a/src/include/eina_inline_lock_wince.x b/src/include/eina_inline_lock_wince.x
index 38d7e08..7877959 100644 (file)
--- a/src/include/eina_inline_lock_wince.x
+++ b/src/include/eina_inline_lock_wince.x
@@ -204,4 +204,6 @@ eina_semaphore_release(Eina_Semaphore *sem EINA_UNUSED,
    return EINA_FALSE;
 }
 
+#include "eina_inline_lock_barrier.x"
+
 #endif

diff --git a/src/include/eina_lock.h b/src/include/eina_lock.h
index f438586..4b7e3bc 100644 (file)
--- a/src/include/eina_lock.h
+++ b/src/include/eina_lock.h
@@ -110,6 +110,14 @@ static inline Eina_Bool eina_semaphore_lock(Eina_Semaphore *sem);
 /** @relates static Eina_Bool eina_semaphore_release(sem_t *sem, int count_release) */
 static inline Eina_Bool eina_semaphore_release(Eina_Semaphore *sem, int count_release);
 
+/** @relates static Eina_Bool eina_barrier_new(Eina_Barrier *barrier, int needed) @since 1.8 */
+static inline Eina_Bool eina_barrier_new(Eina_Barrier *barrier, int needed);
+/** @relates static void eina_barrier_free(Eina_Barrier *barrier); @since 1.8 */
+static inline void eina_barrier_free(Eina_Barrier *barrier);
+/** @relates static Eina_Bool eina_barrier_wait(Eina_Barrier *barrier); @since 1.8 */
+static inline Eina_Bool eina_barrier_wait(Eina_Barrier *barrier);
+
+
 #ifdef EINA_HAVE_DEBUG_THREADS
 # define EINA_MAIN_LOOP_CHECK_RETURN_VAL(val)                          \
   do {                                                                 \