source: branches/2.0/drmaa2_utils/drmaa_utils/thread.c @ 77

/* $Id: thread.c 13 2011-04-20 15:41:43Z mmamonski $ */
/*
 *  PSNC DRMAA 2.0 utilities library
 *  Copyright (C) 2012  Poznan Supercomputing and Networking Center
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * @file thread.c
 * Implementation of recursive mutexes for systems without native support
 * for it.
 */


#ifdef HAVE_CONFIG_H
#       include <config.h>
#endif

#include <drmaa_utils/thread.h>
#include <drmaa_utils/common.h>
#include <errno.h>
#include <unistd.h>

#ifdef HAVE_GETTID
#include <sys/types.h>
#include <sys/syscall.h>
pid_t gettid(void)
{
        return (pid_t)syscall( __NR_gettid );
}
#endif

#ifndef lint
static char rcsid[]
#       ifdef __GNUC__
                __attribute__ ((unused))
#       endif
        = "$Id: thread.c 13 2011-04-20 15:41:43Z mmamonski $";
#endif


void
fsd_thread_create( fsd_thread_t *thread, void* (*func)(void*), void *arg )
{
        int errno_ = 0;
        errno_ = pthread_create( thread, NULL, func, arg );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
}

void
fsd_thread_join( fsd_thread_t th, void **thread_return )
{
        int errno_ = 0;
        errno_ = pthread_join( th, thread_return );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
}

void
fsd_thread_detach( fsd_thread_t th )
{
        int errno_ = 0;
        errno_ = pthread_detach( th );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
}


#if HAVE_RECURSIVE_MUTEXES

void
fsd_mutex_init( fsd_mutex_t *mutex )
{
        int errno_ = 0;
        pthread_mutexattr_t attr;
        do {
                errno_ = pthread_mutexattr_init( &attr );
                if( errno_ )  break;
                errno_ = pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE_NP );
                if( errno_ )  break;
                errno_ = pthread_mutex_init( mutex, &attr );
                if( errno_ )  break;
                errno_ = pthread_mutexattr_destroy( &attr );
        } while( false );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
}

void
fsd_mutex_destroy( fsd_mutex_t *mutex )
{
        int errno_ = 0;
        errno_ = pthread_mutex_destroy( mutex );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
}

bool
fsd_mutex_lock( fsd_mutex_t *mutex )
{
        int errno_ = 0;
        errno_ = pthread_mutex_lock( mutex );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
        return true;
}

bool
fsd_mutex_unlock( fsd_mutex_t *mutex )
{
        int errno_ = 0;
        errno_ = pthread_mutex_unlock( mutex );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
        return false;
}

bool
fsd_mutex_trylock( fsd_mutex_t *mutex )
{
        int errno_ = 0;
        errno_ = pthread_mutex_trylock( mutex );
        switch( errno_ )
         {
                case 0:
                        return true;
                case EBUSY:
                        return false;
                default:
                        fsd_exc_raise_sys( errno_ );
         }
}

int
fsd_mutex_unlock_times( fsd_mutex_t *mutex )
{
        int count = 0;
        int errno_ = 0;
        while( errno_ == 0 )
         {
                errno_ = pthread_mutex_unlock( mutex );
                if( !errno_ )
                        count++;
         }
        if( errno_ != EPERM  ||  count == 0 )
                fsd_exc_raise_sys( errno_ );
        return count;
}

void
fsd_cond_init( fsd_cond_t *cond )
{
        int errno_ = 0;
        errno_ = pthread_cond_init( cond, NULL );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
}

void
fsd_cond_destroy( fsd_cond_t *cond )
{
        int errno_ = 0;
        errno_ = pthread_cond_destroy( cond );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
}

void
fsd_cond_signal( fsd_cond_t *cond )
{
        int errno_ = 0;
        errno_ = pthread_cond_signal( cond );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
}

void
fsd_cond_broadcast( fsd_cond_t *cond )
{
        int errno_ = 0;
        errno_ = pthread_cond_broadcast( cond );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
}

void
fsd_cond_wait( fsd_cond_t *cond, fsd_mutex_t *mutex )
{
        int errno_ = 0;
        errno_ = pthread_cond_wait( cond, mutex );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
}

bool
fsd_cond_timedwait( fsd_cond_t *cond, fsd_mutex_t *mutex,
                const struct timespec *abstime )
{
        int errno_ = 0;
        errno_ = pthread_cond_timedwait( cond, mutex, abstime );
        switch( errno_ )
         {
                case 0:
                        return true;
                case ETIMEDOUT:
                        return false;
                default:
                        fsd_exc_raise_sys( errno_ );
         }
}

#else /* ! HAVE_RECURSIVE_MUTEXES */

void
fsd_mutex_init( fsd_mutex_t *mutex )
{
        int errno_ = 0;
        mutex->owner = (pthread_t)-1;
        mutex->acquired = 0;
        errno_ = pthread_mutex_init( &mutex->mutex, NULL );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
}

void
fsd_mutex_destroy( fsd_mutex_t *mutex )
{
        int errno_ = 0;
        errno_ = pthread_mutex_destroy( &mutex->mutex );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
}

bool
fsd_mutex_lock( fsd_mutex_t *mutex )
{
        /* Note: The order of checks is significant. */
        if( mutex->acquired  &&  pthread_equal( mutex->owner, pthread_self() ) )
                mutex->acquired ++;
        else
         {
                int errno_ = 0;
                errno_ = pthread_mutex_lock( &mutex->mutex );
                if( errno_ == 0 )
                 {
                        mutex->owner    = pthread_self();
                        mutex->acquired = 1;
                 }
                else
                        fsd_exc_raise_sys( errno_ );
         }
        return true;
}

bool
fsd_mutex_unlock( fsd_mutex_t *mutex )
{
        fsd_assert( mutex->acquired
                        &&  pthread_equal( mutex->owner, pthread_self() ) );
        if( -- (mutex->acquired) == 0 )
         {
                int errno_ = 0;
                errno_ = pthread_mutex_unlock( &mutex->mutex );
                if( errno_ )
                        fsd_exc_raise_sys( errno_ );
         }
        return false;
}

bool
fsd_mutex_trylock( fsd_mutex_t *mutex )
{
        if( mutex->acquired  &&  pthread_equal( mutex->owner, pthread_self() ) )
         {
                mutex->acquired ++;
                return true;
         }
        else
         {
                int errno_ = 0;
                errno_ = pthread_mutex_trylock( &mutex->mutex );
                switch( errno_ )
                 {
                        case 0:
                                mutex->owner    = pthread_self();
                                mutex->acquired = 1;
                                return true;
                        case ETIMEDOUT:
                                return false;
                        default:
                                fsd_exc_raise_sys( errno_ );
                 }
         }
}

int
fsd_mutex_unlock_times( fsd_mutex_t *mutex )
{
        int errno_ = 0;
        int count = 0;
        fsd_assert( mutex->acquired
                        &&  pthread_equal( mutex->owner, pthread_self() ) );
        count = mutex->acquired;
        mutex->acquired = 0;
        errno_ = pthread_mutex_unlock( &mutex->mutex );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
        return count;
}

void
fsd_cond_init( fsd_cond_t *cond )
{
        int errno_ = 0;
        errno_ = pthread_cond_init( cond, NULL );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
}

void
fsd_cond_destroy( fsd_cond_t *cond )
{
        int errno_ = 0;
        errno_ = pthread_cond_destroy( cond );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
}

void
fsd_cond_signal( fsd_cond_t *cond )
{
        int errno_ = 0;
        errno_ = pthread_cond_signal( cond );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
}

void
fsd_cond_broadcast( fsd_cond_t *cond )
{
        int errno_ = 0;
        errno_ = pthread_cond_broadcast( cond );
        if( errno_ )
                fsd_exc_raise_sys( errno_ );
}

void
fsd_cond_wait( fsd_cond_t *cond, fsd_mutex_t *mutex )
{
        int errno_ = 0;
        int acquired_save = mutex->acquired;
        fsd_assert( mutex->acquired
                        &&  pthread_equal( mutex->owner, pthread_self() ) );
        errno_ = pthread_cond_wait( cond, &mutex->mutex );
        if( errno_ == 0 )
         {
                mutex->owner = pthread_self();
                mutex->acquired = acquired_save;
         }
        else
                fsd_exc_raise_sys( errno_ );
}

bool
fsd_cond_timedwait( fsd_cond_t *cond, fsd_mutex_t *mutex,
                const struct timespec *abstime )
{
        int errno_ = 0;
        int acquired_save = mutex->acquired;
        fsd_assert( mutex->acquired
                        &&  pthread_equal( mutex->owner, pthread_self() ) );
        errno_ = pthread_cond_timedwait( cond, &mutex->mutex, abstime );
        switch( errno_ )
         {
                case 0:
                        mutex->owner = pthread_self();
                        mutex->acquired = acquired_save;
                        return true;
                case ETIMEDOUT:
                        mutex->owner = pthread_self();
                        mutex->acquired = acquired_save;
                        return false;
                default:
                        fsd_exc_raise_sys( errno_ );
         }
}

#endif /* ! HAVE_RECURSIVE_MUTEXES */



int
fsd_thread_id(void)
{
#if HAVE_GETTID
        /*
         * On Linux 2.6 (with NPTL) getpid() returns
         * same value for all threads in single process.
         */
        return (int)gettid();
#else
        return (int)getpid();
#endif
}