#ifdef __APPLE__
# include <sys/time.h> /* gettimeofday in vlc_cond_timedwait */
+# include <mach/mach_init.h> /* mach_task_self in semaphores */
#endif
/**
vlc_thread_fatal (const char *action, int error,
const char *function, const char *file, unsigned line)
{
+ int canc = vlc_savecancel ();
fprintf (stderr, "LibVLC fatal error %s (%d) in thread %lu ",
action, error, vlc_threadid ());
vlc_trace (function, file, line);
#endif
fflush (stderr);
+ vlc_restorecancel (canc);
abort ();
}
# define VLC_THREAD_ASSERT( action ) \
- if (val) vlc_thread_fatal (action, val, __func__, __FILE__, __LINE__)
+ if (unlikely(val)) \
+ vlc_thread_fatal (action, val, __func__, __FILE__, __LINE__)
#else
# define VLC_THREAD_ASSERT( action ) ((void)val)
#endif
{
pthread_mutexattr_t attr;
- if( pthread_mutexattr_init( &attr ) )
+ if (unlikely(pthread_mutexattr_init (&attr)))
abort();
#ifdef NDEBUG
pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_NORMAL );
pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_ERRORCHECK );
# endif
#endif
- if( pthread_mutex_init( p_mutex, &attr ) )
+ if (unlikely(pthread_mutex_init (p_mutex, &attr)))
abort();
pthread_mutexattr_destroy( &attr );
}
{
pthread_mutexattr_t attr;
- pthread_mutexattr_init( &attr );
+ if (unlikely(pthread_mutexattr_init (&attr)))
+ abort();
#if defined (__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ < 6)
pthread_mutexattr_setkind_np( &attr, PTHREAD_MUTEX_RECURSIVE_NP );
#else
pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
#endif
- if( pthread_mutex_init( p_mutex, &attr ) )
+ if (unlikely(pthread_mutex_init (p_mutex, &attr)))
abort();
pthread_mutexattr_destroy( &attr );
}
VLC_THREAD_ASSERT ("unlocking mutex");
}
-/*****************************************************************************
- * vlc_cond_init: initialize a condition variable
- *****************************************************************************/
-void vlc_cond_init( vlc_cond_t *p_condvar )
+/**
+ * Initializes a condition variable.
+ */
+void vlc_cond_init (vlc_cond_t *p_condvar)
{
pthread_condattr_t attr;
- if (pthread_condattr_init (&attr))
+ if (unlikely(pthread_condattr_init (&attr)))
abort ();
#if !defined (_POSIX_CLOCK_SELECTION)
/* Fairly outdated POSIX support (that was defined in 2001) */
pthread_condattr_setclock (&attr, CLOCK_MONOTONIC);
#endif
- if (pthread_cond_init (p_condvar, &attr))
+ if (unlikely(pthread_cond_init (p_condvar, &attr)))
abort ();
pthread_condattr_destroy (&attr);
}
+/**
+ * Initializes a condition variable.
+ * Contrary to vlc_cond_init(), the wall clock will be used as a reference for
+ * the vlc_cond_timedwait() time-out parameter.
+ */
+void vlc_cond_init_daytime (vlc_cond_t *p_condvar)
+{
+ if (unlikely(pthread_cond_init (p_condvar, NULL)))
+ abort ();
+}
+
/**
* Destroys a condition variable. No threads shall be waiting or signaling the
* condition.
/**
* Waits for a condition variable up to a certain date.
- * This works like vlc_cond_wait(), except for the additional timeout.
+ * This works like vlc_cond_wait(), except for the additional time-out.
+ *
+ * If the variable was initialized with vlc_cond_init(), the timeout has the
+ * same arbitrary origin as mdate(). If the variable was initialized with
+ * vlc_cond_init_daytime(), the timeout is expressed from the Unix epoch.
*
* @param p_condvar condition variable to wait on
* @param p_mutex mutex which is unlocked while waiting,
mtime_t deadline)
{
#if defined(__APPLE__) && !defined(__powerpc__) && !defined( __ppc__ ) && !defined( __ppc64__ )
- /* mdate() is mac_absolute_time on OSX, which we must convert to do
- * the same base than gettimeofday() which pthread_cond_timedwait
- * relies on. */
- mtime_t oldbase = mdate();
- struct timeval tv;
- gettimeofday(&tv, NULL);
- mtime_t newbase = (mtime_t)tv.tv_sec * 1000000 + (mtime_t) tv.tv_usec;
- deadline = deadline - oldbase + newbase;
-#endif
+ /* mdate() is the monotonic clock, timedwait origin is gettimeofday() which
+ * isn't monotonic. Use imedwait_relative_np() instead
+ */
+ mtime_t base = mdate();
+ deadline -= base;
+ if (deadline < 0)
+ deadline = 0;
lldiv_t d = lldiv( deadline, CLOCK_FREQ );
struct timespec ts = { d.quot, d.rem * (1000000000 / CLOCK_FREQ) };
+ int val = pthread_cond_timedwait_relative_np(p_condvar, p_mutex, &ts);
+ if (val != ETIMEDOUT)
+ VLC_THREAD_ASSERT ("timed-waiting on condition");
+ return val;
+#else
+ lldiv_t d = lldiv( deadline, CLOCK_FREQ );
+ struct timespec ts = { d.quot, d.rem * (1000000000 / CLOCK_FREQ) };
int val = pthread_cond_timedwait (p_condvar, p_mutex, &ts);
if (val != ETIMEDOUT)
VLC_THREAD_ASSERT ("timed-waiting on condition");
return val;
+#endif
}
/**
*/
void vlc_sem_init (vlc_sem_t *sem, unsigned value)
{
- if (sem_init (sem, 0, value))
+#if defined(__APPLE__)
+ if (unlikely(semaphore_create(mach_task_self(), sem, SYNC_POLICY_FIFO, value) != KERN_SUCCESS))
abort ();
+#else
+ if (unlikely(sem_init (sem, 0, value)))
+ abort ();
+#endif
}
/**
*/
void vlc_sem_destroy (vlc_sem_t *sem)
{
- int val = sem_destroy (sem);
+ int val;
+
+#if defined(__APPLE__)
+ if (likely(semaphore_destroy(mach_task_self(), *sem) == KERN_SUCCESS))
+ return;
+
+ val = EINVAL;
+#else
+ if (likely(sem_destroy (sem) == 0))
+ return;
+
+ val = errno;
+#endif
+
VLC_THREAD_ASSERT ("destroying semaphore");
}
/**
* Increments the value of a semaphore.
+ * @return 0 on success, EOVERFLOW in case of integer overflow
*/
int vlc_sem_post (vlc_sem_t *sem)
{
- int val = sem_post (sem);
- if (val != EOVERFLOW)
+ int val;
+
+#if defined(__APPLE__)
+ if (likely(semaphore_signal(*sem) == KERN_SUCCESS))
+ return 0;
+
+ val = EINVAL;
+#else
+ if (likely(sem_post (sem) == 0))
+ return 0;
+
+ val = errno;
+#endif
+
+ if (unlikely(val != EOVERFLOW))
VLC_THREAD_ASSERT ("unlocking semaphore");
return val;
}
void vlc_sem_wait (vlc_sem_t *sem)
{
int val;
+
+#if defined(__APPLE__)
+ if (likely(semaphore_wait(*sem) == KERN_SUCCESS))
+ return;
+
+ val = EINVAL;
+#else
do
- val = sem_wait (sem);
- while (val == EINTR);
+ if (likely(sem_wait (sem) == 0))
+ return;
+ while ((val = errno) == EINTR);
+#endif
+
VLC_THREAD_ASSERT ("locking semaphore");
}
*/
void vlc_rwlock_init (vlc_rwlock_t *lock)
{
- if (pthread_rwlock_init (lock, NULL))
+ if (unlikely(pthread_rwlock_init (lock, NULL)))
abort ();
}
if (!initialized)
{
#ifndef __APPLE__
- if (config_GetInt (p_libvlc, "rt-priority"))
+ if (var_InheritBool (p_libvlc, "rt-priority"))
#endif
{
- rt_offset = config_GetInt (p_libvlc, "rt-offset");
+ rt_offset = var_InheritInteger (p_libvlc, "rt-offset");
rt_priorities = true;
}
initialized = true;
void vlc_cancel (vlc_thread_t thread_id)
{
pthread_cancel (thread_id);
+#ifdef HAVE_MAEMO
+ pthread_kill (thread_id, SIGRTMIN);
+#endif
}
/**
/* This should fail if an invalid value for given for state */
VLC_THREAD_ASSERT ("restoring cancellation");
- if (oldstate != PTHREAD_CANCEL_DISABLE)
+ if (unlikely(oldstate != PTHREAD_CANCEL_DISABLE))
vlc_thread_fatal ("restoring cancellation while not disabled", EINVAL,
__func__, __FILE__, __LINE__);
#else
{
struct vlc_timer *timer = malloc (sizeof (*timer));
- if (timer == NULL)
+ if (unlikely(timer == NULL))
return ENOMEM;
vlc_mutex_init (&timer->lock);
vlc_cond_init (&timer->wait);