source: svn/trunk/newcon3bcm2_21bu/dta/src/sim/bos_pthread.c

#include <stdlib.h>
#include <pthread.h>
#include <sys/time.h>
#include "bstd.h"
#include "bos.h"
#include "genericlist.h"

typedef struct bos_event_t
{
        LINKS_T                 links;
        b_event_t               *event;
}bos_event_t;

typedef struct bos_queue_t
{
        LIST_T                  list;
        pthread_mutex_t mutex;
}bos_queue_t;

int g_ticks_per_ms = 1;
static pthread_mutex_t s_mutex = PTHREAD_MUTEX_INITIALIZER;
static int lflag = 0;

void bos_init(void)
{
}
void bos_start(void)
{
}

bresult bos_start_task( b_task_t *handle, const b_task_params *params, b_task_func func,  void *data )
{
    if (pthread_create((pthread_t*)handle, NULL,
              (void *(*)(void*))func, data) == 0)
        {
                return b_ok;
        }
        return berr_out_of_memory;
}
void bos_stop_task(b_task_t handle)
{
#ifndef __MINGW32__
    pthread_kill((pthread_t*)handle,-9);
#endif
}


bresult bos_create_queue(  b_queue_t *handle, b_event_t *events, int num_events )
{
        bos_queue_t *p_bq = (bos_queue_t*)malloc(sizeof(bos_queue_t));
        if (!p_bq)
                return berr_out_of_memory;

        if (pthread_mutex_init(&p_bq->mutex,NULL) != 0)
        {
                free(p_bq);
                return berr_out_of_memory;
        }

        initl(&p_bq->list);
        *handle = (b_queue_t)p_bq;
        return b_ok;
}

void bos_delete_queue(  b_queue_t *handle )
{
        bos_queue_t *p_bq = (bos_queue_t*)handle;
        bos_event_t *p_evt;

        for (p_evt = (bos_event_t*)remlh(&p_bq->list); p_evt != NULL; p_evt = (bos_event_t*)remlh(&p_bq->list)) 
        {
                free(p_evt);
        }
        free(p_bq);
}
bresult bos_post_event( b_queue_t handle, b_event_t *event )
{
        bos_queue_t *p_bq = (bos_queue_t*)handle;
        bos_event_t *p_evt = NULL;
        
        p_evt = (bos_event_t*)malloc(sizeof(bos_event_t));
        if (!p_bq)
                return berr_out_of_memory;

        if (pthread_mutex_lock((pthread_mutex_t *)&p_bq->mutex) != 0)
                goto error;

        p_evt->event = event;
        inslt(&p_bq->list,p_evt);
        pthread_mutex_unlock((pthread_mutex_t *)&p_bq->mutex);

        return b_ok;

error:
        if (p_evt)
                free(p_evt);
        return berr_timeout;
        
}
b_event_t *bos_pend_event( b_queue_t handle, int timeout_ms )
{
        bos_queue_t *p_bq = (bos_queue_t*)handle;
        bos_event_t *p_evt = NULL;
        b_event_t *return_event = NULL;

        unsigned int timout_ticks = bos_getticks() + timeout_ms * g_ticks_per_ms;;

        if (pthread_mutex_lock((pthread_mutex_t *)&p_bq->mutex) != 0)
                goto exit;

        while (LEMPTY(&p_bq->list))
        {
                pthread_mutex_unlock((pthread_mutex_t *)&p_bq->mutex);
                bos_sleep(1);
                
                if (timeout_ms >= 0)
                {
                        if (timout_ticks < bos_getticks())
                                goto exit;
                }
                
                if (pthread_mutex_lock((pthread_mutex_t *)&p_bq->mutex) != 0)
                        goto exit;
        }
        p_evt = (bos_event_t*)LHEAD(&p_bq->list);
        reml(&p_bq->list,p_evt);
        return_event = p_evt->event;
        free(p_evt);
        pthread_mutex_unlock((pthread_mutex_t *)&p_bq->mutex);
        
exit:
        return return_event;
}
bresult bos_create_mutex( b_mutex_t *handle )
{
        handle->queue = (b_queue_t)malloc(sizeof(pthread_mutex_t));
        if (pthread_mutex_init((pthread_mutex_t *)(handle->queue),NULL) == 0)
                return b_ok;
        return berr_out_of_memory;
}
void bos_delete_mutex( b_mutex_t *handle)
{
        pthread_mutex_destroy((pthread_mutex_t *)(handle->queue));
        free((void*)(handle->queue));
}
bresult bos_acquire_mutex( b_mutex_t *handle, int timeout_ms  )
{
        if (timeout_ms < 0)
        {
                if (pthread_mutex_lock((pthread_mutex_t *)(handle->queue)) != 0)
                        return berr_timeout; 
        }
        else
        {
                unsigned int timout_ticks = bos_getticks() + timeout_ms * g_ticks_per_ms;
                while (pthread_mutex_trylock((pthread_mutex_t *)(handle->queue)) != 0)
                {
                        bos_sleep(1);
                        if (timout_ticks < bos_getticks())
                                return berr_timeout;
                }
        }
        return b_ok;
}
bresult bos_release_mutex( b_mutex_t *handle )
{
        pthread_mutex_unlock((pthread_mutex_t *)(handle->queue));
        return b_ok;
}
void bos_sleep( unsigned int sleep_ms )
{
        if (sleep_ms >=1000)
        {
                g_usleep(sleep_ms * 1000);
        }
        else
        {
                usleep(sleep_ms*1000);
        }
}

static int timeval_subtract (struct timeval *result, struct timeval *x, struct timeval *y)
{
        /* Perform the carry for the later subtraction by updating y. */
        if (x->tv_usec < y->tv_usec)
        {
                int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
                y->tv_usec -= 1000000 * nsec;
                y->tv_sec += nsec;
        }
        if (x->tv_usec - y->tv_usec > 1000000)
        {
                int nsec = (x->tv_usec - y->tv_usec) / 1000000;
                y->tv_usec += 1000000 * nsec;
                y->tv_sec -= nsec;
        }

        /* Compute the time remaining to wait.
           tv_usec is certainly positive. */
        result->tv_sec = x->tv_sec - y->tv_sec;
        result->tv_usec = x->tv_usec - y->tv_usec;

        /* Return 1 if result is negative. */
        return x->tv_sec < y->tv_sec;
}

static struct timeval s_start_time = {0,0};
unsigned int bos_getticks( void )
{
        struct timeval tv;
        struct timeval cur_tv;

        if ((s_start_time.tv_sec == 0) && (s_start_time.tv_usec == 0))
        {
                gettimeofday(&s_start_time,NULL);
        }
        gettimeofday(&cur_tv,NULL);
        timeval_subtract(&tv,&cur_tv,&s_start_time);
        return (tv.tv_sec * 1000 + tv.tv_usec/1000);
}
void bos_getclock(b_clock *clock)
{
}
unsigned int bos_enter_critical(void)
{
        pthread_mutex_lock((pthread_mutex_t *)&s_mutex);
        return lflag++;
}
void bos_exit_critical(unsigned int flags)
{
        pthread_mutex_unlock((pthread_mutex_t *)&s_mutex);
}