pthread_cond_timedeait()

[abraziv]

Всем привет , столкнулся с проблемой .

Есть код

#include <pthread.h>

//#include "/home/abraziv/Desktop/glibc-2.14/nptl/sysdeps/pthread"

#include <stdio.h>

#include <time.h>

#include <stdio.h>

#include <sys/time.h>

#include <errno.h>

void out(int );

void* compute_thread (void*);

int lab_pthread_cond_timedwait(pthread_cond_t * ,pthread_mutex_t *, unsigned int );

pthread_mutex_t my_sync;

pthread_cond_t rx;

unsigned int tw = 100;

struct timespec timetowait ;

int retcode = 1 ;

int thread_done = 0;

int x=1;

main( )

{

pthread_t tid;

pthread_attr_t attr;

pthread_attr_init (&attr);

pthread_mutex_init (&my_sync, NULL);

pthread_cond_init (&rx, NULL);

pthread_create(&tid, &attr, compute_thread, (void *)NULL);

pthread_mutex_lock(&my_sync);

out(3);

while (!thread_done)

{

lab_pthread_cond_timedwait(&rx, &my_sync, tw );

pthread_cond_wait(&rx, &my_sync );

}

out(4);

x++;

pthread_mutex_unlock(&my_sync);

out(5);

exit(0);

}

void* compute_thread(void* dummy)

{

out(6);

pthread_mutex_lock (&my_sync);

out(8);

x++;

sleep(2);

out(9);

thread_done = 1;

pthread_cond_signal (&rx);

out(10);

pthread_mutex_unlock (&my_sync);

out(11);

return;

}

void out(int sh)

{

printf("%d rx.__data.__lock %d\n",sh,rx.__data.__lock );

printf("%d rx.__data.__futex %d\n",sh,rx.__data.__futex );

printf("%d rx.__data.__total_seq %d\n",sh,rx.__data.__total_seq );

printf("%d rx.__data.__wakeup_seq %d\n",sh,rx.__data.__wakeup_seq );

printf("%d rx.__data.__woken_seq %d\n",sh,rx.__data.__woken_seq );

printf("%d rx.__data.__nwaiters %d\n",sh,rx.__data.__nwaiters );

printf("%d rx.__data.__mutex %d\n",sh,rx.__data.__mutex );

printf("%d rx.__data.__broadcast_seq %d\n",sh,rx.__data.__broadcast_seq );

printf("%d my_sync.__data.__lock %d\n",sh,my_sync.__data.__lock );

printf("%d my_sync.__data.__nwaiters %d\n",sh,my_sync.__data.__count );

printf("%d my_sync.__data.__mutex %d\n",sh,my_sync.__data.__owner );

printf("%d my_sync.__data.__broadcast_seq %d\n\n",sh,my_sync.__data.__nusers );

}

lab_pthread_cond_timedwait(pthread_cond_t *rx,pthread_mutex_t *my_sync, unsigned int timetowait)

{

}

[/C]

Мне необходимо написать функцию , подобную pthread_cond_timedwait(), которая по истечению заданого времени (например 1 сек ) времени подымала какой либо флаг. Проблема заключается в том , что эта функция должна работать без участия выполняющихся потоков . Т.е. один поток захватывает мьютекс потом натыкается pthread_cond_wait(&rx, &my_sync ) и блокируется на этой условной переменной , после переключения другой поток начинает выполнять функцию compute_thread() . и поподает на sleep(2) , засыпает на 2 или более сек . И т.к. 2 или более сек больше чем 1 (аргумент моей функции) выставлется бит , например в __data.__woken_seq .

Это можно сделать по аналогии с функцией pthread_cond_timedwait()

struct _condvar_cleanup_buffer

{

int oldtype;

pthread_cond_t *cond;

pthread_mutex_t *mutex;

unsigned int bc_seq;

};

int

__pthread_cond_timedwait (cond, mutex, abstime)

pthread_cond_t *cond;

pthread_mutex_t *mutex;

const struct timespec *abstime;

{

struct _pthread_cleanup_buffer buffer;

struct _condvar_cleanup_buffer cbuffer;

int result = 0;

/* Catch invalid parameters. */

if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)

return EINVAL;

int pshared = (cond->__data.__mutex == (void *) ~0l)

? LLL_SHARED : LLL_PRIVATE;

/* Make sure we are alone. */

lll_lock (cond->__data.__lock, pshared);

/* Now we can release the mutex. */

int err = __pthread_mutex_unlock_usercnt (mutex, 0);

if (err)

{

lll_unlock (cond->__data.__lock, pshared);

return err;

}

/* We have one new user of the condvar. */

++cond->__data.__total_seq;

++cond->__data.__futex;

cond->__data.__nwaiters += 1 << COND_NWAITERS_SHIFT;

/* Remember the mutex we are using here. If there is already a

different address store this is a bad user bug. Do not store

anything for pshared condvars. */

if (cond->__data.__mutex != (void *) ~0l)

cond->__data.__mutex = mutex;

/* Prepare structure passed to cancellation handler. */

cbuffer.cond = cond;

cbuffer.mutex = mutex;

/* Before we block we enable cancellation. Therefore we have to

install a cancellation handler. */

__pthread_cleanup_push (&buffer, __condvar_cleanup, &cbuffer);

/* The current values of the wakeup counter. The "woken" counter

must exceed this value. */

unsigned long long int val;

unsigned long long int seq;

val = seq = cond->__data.__wakeup_seq;

/* Remember the broadcast counter. */

cbuffer.bc_seq = cond->__data.__broadcast_seq;

while (1)

{

struct timespec rt;

{

#ifdef __NR_clock_gettime

INTERNAL_SYSCALL_DECL (err);

int ret;

ret = INTERNAL_VSYSCALL (clock_gettime, err, 2,

(cond->__data.__nwaiters

& ((1 << COND_NWAITERS_SHIFT) - 1)),

&rt);

# ifndef __ASSUME_POSIX_TIMERS

if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (ret, err), 0))

{

struct timeval tv;

(void) gettimeofday (&tv, NULL);

/* Convert the absolute timeout value to a relative timeout. */

rt.tv_sec = abstime->tv_sec - tv.tv_sec;

rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;

}

else

# endif

{

/* Convert the absolute timeout value to a relative timeout. */

rt.tv_sec = abstime->tv_sec - rt.tv_sec;

rt.tv_nsec = abstime->tv_nsec - rt.tv_nsec;

}

#else

/* Get the current time. So far we support only one clock. */

struct timeval tv;

(void) gettimeofday (&tv, NULL);

/* Convert the absolute timeout value to a relative timeout. */

rt.tv_sec = abstime->tv_sec - tv.tv_sec;

rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;

#endif

}

if (rt.tv_nsec < 0)

{

rt.tv_nsec += 1000000000;

--rt.tv_sec;

}

/* Did we already time out? */

if (__builtin_expect (rt.tv_sec < 0, 0))

{

if (cbuffer.bc_seq != cond->__data.__broadcast_seq)

goto bc_out;

goto timeout;

}

unsigned int futex_val = cond->__data.__futex;

/* Prepare to wait. Release the condvar futex. */

lll_unlock (cond->__data.__lock, pshared);

/* Enable asynchronous cancellation. Required by the standard. */

cbuffer.oldtype = __pthread_enable_asynccancel ();

/* Wait until woken by signal or broadcast. */

err = lll_futex_timed_wait (&cond->__data.__futex,

futex_val, &rt, pshared);

/* Disable asynchronous cancellation. */

__pthread_disable_asynccancel (cbuffer.oldtype);

/* We are going to look at shared data again, so get the lock. */

lll_lock (cond->__data.__lock, pshared);

/* If a broadcast happened, we are done. */

if (cbuffer.bc_seq != cond->__data.__broadcast_seq)

goto bc_out;

/* Check whether we are eligible for wakeup. */

val = cond->__data.__wakeup_seq;

cond->__data.__wakeup_seq

if (val != seq && cond->__data.__woken_seq != val)

break;

/* Not woken yet. Maybe the time expired? */

if (__builtin_expect (err == -ETIMEDOUT, 0))

{

timeout:

/* Yep. Adjust the counters. */

++cond->__data.__wakeup_seq;

++cond->__data.__futex;

/* The error value. */

result = ETIMEDOUT;

break;

}

}

/* Another thread woken up. */

++cond->__data.__woken_seq;

bc_out:

cond->__data.__nwaiters -= 1 << COND_NWAITERS_SHIFT;

/* If pthread_cond_destroy was called on this variable already,

notify the pthread_cond_destroy caller all waiters have left

and it can be successfully destroyed. */

if (cond->__data.__total_seq == -1ULL

&& cond->__data.__nwaiters < (1 << COND_NWAITERS_SHIFT))

lll_futex_wake (&cond->__data.__nwaiters, 1, pshared);

/* We are done with the condvar. */

lll_unlock (cond->__data.__lock, pshared);

/* The cancellation handling is back to normal, remove the handler. */

__pthread_cleanup_pop (&buffer, 0);

/* Get the mutex before returning. */

err = __pthread_mutex_cond_lock (mutex);

return err ?: result;

}

[/C]

Но я незнаю какую часть кода необходимо вытащить, есть предположения , но я не слишком силён в программирование . Спасибо заранее.