Всем привет , столкнулся с проблемой .
Есть код
#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]
Но я незнаю какую часть кода необходимо вытащить, есть предположения , но я не слишком силён в программирование . Спасибо заранее.