Example #1
0
static void *
tf (void *arg)
{
  pthread_rwlock_t *r = arg;

  /* Timeout: 0.3 secs.  */
  struct timespec ts_start;
  xclock_gettime (CLOCK_REALTIME, &ts_start);
  const struct timespec ts_timeout = timespec_add (ts_start,
                                                   make_timespec (0, 300000000));

  TEST_COMPARE (pthread_rwlock_timedwrlock (r, &ts_timeout), ETIMEDOUT);
  puts ("child: timedwrlock failed with ETIMEDOUT");

  TEST_TIMESPEC_NOW_OR_AFTER (CLOCK_REALTIME, ts_timeout);

  struct timespec ts_invalid;
  xclock_gettime (CLOCK_REALTIME, &ts_invalid);
  ts_invalid.tv_sec += 10;
  /* Note that the following operation makes ts invalid.  */
  ts_invalid.tv_nsec += 1000000000;

  TEST_COMPARE (pthread_rwlock_timedwrlock (r, &ts_invalid), EINVAL);

  puts ("child: timedwrlock failed with EINVAL");

  return NULL;
}
Example #2
0
static TACommandVerdict pthread_rwlock_timedwrlock_cmd(TAThread thread, TAInputStream stream)
{
    pthread_rwlock_t* rwlock;
    TimeUnit          delta;
    struct timespec   timeout;
    int res;

    // Prepare
    rwlock  = readPointer(&stream);
    delta   = readTimeUnit(&stream);        // Reading the relative time

    BEFORE_BLOCKED_TARGET_OPERATION(thread);

    timeout = addTimeUnit(thread->start_time, delta);       // Get the absolute timeout value

    writeString(thread, "Ok");
    sendResponse(thread);

    START_TARGET_OPERATION(thread);

    // Execute
    res = pthread_rwlock_timedwrlock(rwlock, &timeout);

    END_TARGET_OPERATION(thread);

    // Response
    writeDeferredReaction(thread, "pthread_rwlock_timedwrlock_return");
    writeInt(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}
Example #3
0
static TACommandVerdict pthread_rwlock_timedwrlock_bad_cmd(TAThread thread, TAInputStream stream)
{
    pthread_rwlock_t* rwlock;
    int               nsec;
    struct timespec   timeout;
    int res;

    // Prepare
    rwlock = readPointer(&stream);
    nsec   = readInt(&stream);

    timeout = thread->start_time;
    timeout.tv_sec += 2;
    timeout.tv_nsec = nsec;

    START_TARGET_OPERATION(thread);

    // Execute
    res = pthread_rwlock_timedwrlock(rwlock, &timeout);

    END_TARGET_OPERATION(thread);

    // Response
    writeInt(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}
Example #4
0
int
main()
{
    pthread_t t;
    struct timespec abstime = { 0, 0 };
    struct _timeb currSysTime;
    const DWORD NANOSEC_PER_MILLISEC = 1000000;

    _ftime(&currSysTime);

    abstime.tv_sec = currSysTime.time;
    abstime.tv_nsec = NANOSEC_PER_MILLISEC * currSysTime.millitm;

    abstime.tv_sec += 1;

    assert(pthread_rwlock_timedwrlock(&rwlock1, &abstime) == 0);

    assert(pthread_create(&t, NULL, func, NULL) == 0);

    Sleep(2000);

    assert(pthread_rwlock_unlock(&rwlock1) == 0);

    assert(washere == 1);

    return 0;
}
Example #5
0
static void *
th (void *arg)
{
  long int res = 0;
  int r;
  struct timespec t = { -2, 0 };

  r = pthread_mutex_timedlock (&m1, &t);
  if (r != ETIMEDOUT)
    {
      puts ("pthread_mutex_timedlock did not return ETIMEDOUT");
      res = 1;
    }
  r = pthread_rwlock_timedrdlock (&rw1, &t);
  if (r != ETIMEDOUT)
    {
      puts ("pthread_rwlock_timedrdlock did not return ETIMEDOUT");
      res = 1;
    }
  r = pthread_rwlock_timedwrlock (&rw2, &t);
  if (r != ETIMEDOUT)
    {
      puts ("pthread_rwlock_timedwrlock did not return ETIMEDOUT");
      res = 1;
    }
  return (void *) res;
}
Example #6
0
int main(int argc, char** argv)
{
  int r;
  pthread_mutex_t mutex;
  pthread_rwlock_t rwlock;
  struct timespec abs_timeout;

  time(&abs_timeout.tv_sec);
  abs_timeout.tv_nsec = 0;
  abs_timeout.tv_sec += 10;

  r = pthread_rwlock_init(&rwlock, NULL); assert(r == 0);
  fprintf(stderr, "Locking rwlock via pthread_rwlock_wrlock().\n");
  r = pthread_rwlock_wrlock(&rwlock); assert(r == 0);
  r = pthread_rwlock_unlock(&rwlock); assert(r == 0);
  fprintf(stderr, "Locking rwlock via pthread_rwlock_trywrlock().\n");
  r = pthread_rwlock_trywrlock(&rwlock); assert(r == 0);
  r = pthread_rwlock_unlock(&rwlock); assert(r == 0);
  fprintf(stderr, "Locking rwlock via pthread_rwlock_timedwrlock().\n");
#ifdef HAVE_PTHREAD_RWLOCK_TIMEDWRLOCK
  r = pthread_rwlock_timedwrlock(&rwlock, &abs_timeout); assert(r == 0);
  r = pthread_rwlock_unlock(&rwlock); assert(r == 0);
#endif
  fprintf(stderr, "Locking rwlock via pthread_rwlock_rdlock().\n");
  r = pthread_rwlock_rdlock(&rwlock); assert(r == 0);
  r = pthread_rwlock_rdlock(&rwlock); assert(r == 0);
  r = pthread_rwlock_rdlock(&rwlock); assert(r == 0);
  r = pthread_rwlock_unlock(&rwlock); assert(r == 0);
  r = pthread_rwlock_unlock(&rwlock); assert(r == 0);
  r = pthread_rwlock_unlock(&rwlock); assert(r == 0);
  fprintf(stderr, "Locking rwlock via pthread_rwlock_tryrdlock().\n");
  r = pthread_rwlock_tryrdlock(&rwlock); assert(r == 0);
  r = pthread_rwlock_unlock(&rwlock); assert(r == 0);
  fprintf(stderr, "Locking rwlock via pthread_rwlock_timedrdlock().\n");
#ifdef HAVE_PTHREAD_RWLOCK_TIMEDRDLOCK
  r = pthread_rwlock_timedrdlock(&rwlock, &abs_timeout); assert(r == 0);
  r = pthread_rwlock_unlock(&rwlock); assert(r == 0);
#endif
  fprintf(stderr, "Attempt to lock for writing recursively (not allowed).\n");
  r = pthread_rwlock_wrlock(&rwlock); assert(r == 0);
  r = pthread_rwlock_wrlock(&rwlock); assert(r != 0);
  r = pthread_rwlock_unlock(&rwlock); assert(r == 0);
  r = pthread_rwlock_destroy(&rwlock); assert(r == 0);

  r = pthread_mutex_init(&mutex, NULL); assert(r == 0);
  fprintf(stderr, "Locking mutex via pthread_mutex_trylock().\n");
  r = pthread_mutex_trylock(&mutex); assert(r == 0);
  r = pthread_mutex_unlock(&mutex); assert(r == 0);
  fprintf(stderr, "Locking mutex via pthread_mutex_lock().\n");
  r = pthread_mutex_lock(&mutex); assert(r == 0);
  r = pthread_mutex_unlock(&mutex); assert(r == 0);
  fprintf(stderr, "Locking mutex via pthread_mutex_timedlock().\n");
#ifdef HAVE_PTHREAD_MUTEX_TIMEDLOCK
  r = pthread_mutex_timedlock(&mutex, &abs_timeout); assert(r == 0);
  r = pthread_mutex_unlock(&mutex); assert(r == 0);
#endif
  r = pthread_mutex_destroy(&mutex); assert(r == 0);

  return 0;
}
Example #7
0
bool rw_mutex::impl::write_lock(double sec)
{
#if defined(__linux__) || defined(__sparcv8) || defined(__sparcv9)
  if (!valid) return false;
#ifdef JUBATUS_UTIL_CONCURRENT_RWMUTEX_ERRORCHECK
  assert(holders_lk.lock()==true);
  assert(holders.count(thread::id())==0);
#endif

  bool result;
  if (sec<1e-9) {
    result = pthread_rwlock_trywrlock(&lk)==0;
  } else {
    timespec end=to_timespec(get_clock_time()+sec);
    result = pthread_rwlock_timedwrlock(&lk, &end)==0;
  }
#ifdef JUBATUS_UTIL_CONCURRENT_RWMUTEX_ERRORCHECK
  if (result) holders.insert(thread::id());
  assert(holders_lk.unlock()==true);
#endif
  return result;
#else
  return false;
#endif
}
Example #8
0
static void * th_fn(void *arg)
{
	struct sigaction act;
	struct timespec abs_timeout;
	int rc = 0;

	handler_called = 0;

	/* Set up signal handler for SIGUSR1 */

	act.sa_flags = 0;
	act.sa_handler = sig_handler;
	/* block all the signal when hanlding SIGUSR1 */
	sigfillset(&act.sa_mask);
	sigaction(SIGUSR1, &act, 0);

	gettimeofday(&before_wait, NULL);
	abs_timeout.tv_sec = before_wait.tv_sec + TIMEOUT;
	abs_timeout.tv_nsec = before_wait.tv_usec * 1000;

	printf("thread: attempt timed write lock, %d seconds\n", TIMEOUT);
	thread_state = ENTERED_THREAD;
	rc = pthread_rwlock_timedwrlock(&rwlock, &abs_timeout);
	if (rc != ETIMEDOUT)
	{
		printf("sig_thread: pthread_rwlock_timedwrlock returns %d\n", rc);
		exit(PTS_FAIL);
	}
 	printf("thread: timer correctly expired\n");
	gettimeofday(&after_wait, NULL);

	thread_state = EXITING_THREAD;
	pthread_exit(0);
	return NULL;
}
Example #9
0
wod_ret_t
wod_rwlock_wlock_timeout(wod_rwlock_t *rwlock,long long timeout)
{
	struct timespec tm;
	tm.tv_sec = timeout/1000000;
	tm.tv_nsec = timeout-tm.tv_sec;
	return pthread_rwlock_timedwrlock(&rwlock->rw,&tm);
}
Example #10
0
void test_writer_timedwait(void) {
  fprintf(stderr, "test_writer_timedwait\n");
  tell_thread_to_acquire_lock(READ_LOCK);

  struct timespec t = { 0, 0 };
  int rc = pthread_rwlock_timedwrlock(&g_rwlock, &t);
  ASSERT_EQ(rc, ETIMEDOUT);

  tell_thread_to_release_lock();
}
Example #11
0
File: 3-1.c Project: Nan619/ltp-ddt
static void *fn_wr(void *arg)
{
	struct timespec timeout, ts;
	int rc;
	thread_state = ENTERED_THREAD;
#ifdef CLOCK_REALTIME
	rc = clock_gettime(CLOCK_REALTIME, &ts);
	if (rc != 0) {
		perror("clock_gettime()");
		exit(PTS_UNRESOLVED);
	}
	currsec1.tv_sec = ts.tv_sec;
	currsec1.tv_usec = ts.tv_nsec / 1000;
#else
	gettimeofday(&currsec1, NULL);
#endif
	/* Absolute time, not relative. */
	timeout.tv_sec = currsec1.tv_sec + TIMEOUT;
	timeout.tv_nsec = currsec1.tv_usec * 1000;

	printf("thread: attempt timed write lock, %d secs\n", TIMEOUT);
	rc = pthread_rwlock_timedwrlock(&rwlock, &timeout);
	if (rc == ETIMEDOUT) {
		printf("thread: timer expired\n");
		expired = 1;
	} else if (rc == 0) {
		printf("thread: acquired write lock\n");
		expired = 0;
		printf("thread: unlock write lock\n");
		if (pthread_rwlock_unlock(&rwlock) != 0) {
			printf("thread: error release write lock\n");
			exit(PTS_UNRESOLVED);
		}
	} else {
		printf("thread: Error in pthread_rwlock_timedrdlock().\n");
		exit(PTS_UNRESOLVED);
	}

	/* Get time after the mutex timed out in locking. */
#ifdef CLOCK_REALTIME
	rc = clock_gettime(CLOCK_REALTIME, &ts);
	if (rc != 0) {
		perror("clock_gettime()");
		exit(PTS_UNRESOLVED);
	}
	currsec2.tv_sec = ts.tv_sec;
	currsec2.tv_usec = ts.tv_nsec / 1000;
#else
	gettimeofday(&currsec2, NULL);
#endif
	thread_state = EXITING_THREAD;
	pthread_exit(0);
	return NULL;
}
Example #12
0
static void *
writer_thread (void *nr)
{
  struct timespec ts;
  struct timespec delay;
  int n;

  delay.tv_sec = 0;
  delay.tv_nsec = DELAY;

  for (n = 0; n < WRITETRIES; ++n)
    {
      int e;
      do
	{
	  struct timeval tv;
	  (void) gettimeofday (&tv, NULL);
	  TIMEVAL_TO_TIMESPEC (&tv, &ts);

	  ts.tv_nsec += 2 * TIMEOUT;
	  if (ts.tv_nsec >= 1000000000)
	    {
	      ts.tv_nsec -= 1000000000;
	      ++ts.tv_sec;
	    }

	  printf ("writer thread %ld tries again\n", (long int) nr);

	  e = pthread_rwlock_timedwrlock (&lock, &ts);
	  if (e != 0 && e != ETIMEDOUT)
	    {
	      puts ("timedwrlock failed");
	      exit (1);
	    }
	}
      while (e == ETIMEDOUT);

      printf ("writer thread %ld succeeded\n", (long int) nr);

      nanosleep (&delay, NULL);

      if (pthread_rwlock_unlock (&lock) != 0)
	{
	  puts ("unlock for writer failed");
	  exit (1);
	}

      printf ("writer thread %ld released\n", (long int) nr);
    }

  return NULL;
}
Example #13
0
File: init.c Project: Fyleo/rtems
void *POSIX_Init(
  void *argument
)
{
  int        i;
  int        status;
  pthread_t  threadId;
  pthread_rwlockattr_t attr;

  TEST_BEGIN();

  for ( i=0 ; i < OPERATION_COUNT - 1 ; i++ ) {
    status = pthread_create( &threadId, NULL, Middle, NULL );
    rtems_test_assert( !status );
  }
  
  status = pthread_create( &threadId, NULL, Low, NULL );
  rtems_test_assert( !status );

  /*
   *  Timeout for 5 seconds from now.
   */
  status = clock_gettime( CLOCK_REALTIME, &abstime );
  rtems_test_assert( !status );
  abstime.tv_sec += 5;

  /*
   * Deliberately create the rwlock after the threads.  This way if the
   * threads do run before we intend, they will get an error.
   */
  status = pthread_rwlockattr_init( &attr );
  rtems_test_assert( status == 0 );
    status = pthread_rwlock_init( &rwlock, &attr );
  rtems_test_assert( status == 0 );
  /*
   * Let the other threads start so the thread startup overhead,
   * is accounted for.  When we return, we can start the benchmark.
   */
  sched_yield();
    /* let other threads run */

  
  /* start the timer and switch through all the other tasks */
  benchmark_timer_initialize();

  /* write lock operation, this could be any write lock
   * I decided to use timedwrlock just to continue in the timed line  */
    status = pthread_rwlock_timedwrlock(&rwlock,0);
  rtems_test_assert( status == 0 );
  return NULL;
}
Example #14
0
bool cRwLock::Lock(bool Write, int TimeoutMs)
{
    int Result = 0;
    struct timespec abstime;
    if (TimeoutMs) {
        if (!GetAbsTime(&abstime, TimeoutMs))
            TimeoutMs = 0;
    }
    if (Write)
        Result = TimeoutMs ? pthread_rwlock_timedwrlock(&rwlock, &abstime) : pthread_rwlock_wrlock(&rwlock);
    else
        Result = TimeoutMs ? pthread_rwlock_timedrdlock(&rwlock, &abstime) : pthread_rwlock_rdlock(&rwlock);
    return Result == 0;
}
Example #15
0
static int wr_timedlock(pthread_rwlock_t *lock, int timeout)
{
	tv_t now;
	ts_t abs;
	int ret;

	tv_time(&now);
	tv_to_ts(&abs, &now);
	abs.tv_sec += timeout;

	ret = pthread_rwlock_timedwrlock(lock, &abs);

	return ret;
}
Example #16
0
/**
 * TimeWriteLock
 * @params[in] timeout
 * 
 * This function will attempt to aquire a write lock. It will attempt to try for the timeout specific.
 * If it does aquire the lock true will be return. If the lock is not aquired false will be returned.
 *
 */
bool RWLock::TimeWriteLock(const struct timespec *timeout)
{
	int ret = pthread_rwlock_timedwrlock(&m_lock, timeout);
	if (ret == 0)
		return true;

	switch(ret)
	{
		case ETIMEDOUT:
			return false;
		default:
			abort();
	}
	return false;
}
Example #17
0
bool
cThreadLockRw::TimedWriteLock( unsigned int timeout )
{
  struct timespec t;
  GetTimeout( t, timeout );

  int rv = pthread_rwlock_timedwrlock( &m_rwlock, &t );

  if ( rv )
     {
       assert( rv == ETIMEDOUT );
       return false;
     }

  return true;
}
Example #18
0
// WriteLock with absolute timeout
bool RWLockImplPosix::writeLock(const ::icl_core::TimeStamp& timeout)
{
#ifdef _SYSTEM_DARWIN_
  int ret = pthread_rwlock_trywrlock(m_rwlock);
  while ((ret != 0) && ((timeout > icl_core::TimeStamp::now())))
  {
    // one microsecond
    icl_core::os::usleep(1);
    ret = pthread_rwlock_trywrlock(m_rwlock);
  }
  return (ret == 0);
#else
  struct timespec timeout_timespec = timeout.timespec();
  bool ret = pthread_rwlock_timedwrlock(m_rwlock, &timeout_timespec);
  return (ret == 0);
#endif
}
Example #19
0
static void * th_fn(void *arg)
{
    struct sigaction act;
    struct timespec abs_timeout;
    int rc;
    handler_state = 2;
    expired = 0;

    /* Set up handler for SIGUSR1 */

    act.sa_flags = 0;
    act.sa_handler = sig_handler;
    /* block all the signal when hanlding SIGUSR1 */
    sigfillset(&act.sa_mask);
    sigaction(SIGUSR1, &act, 0);

    gettimeofday(&before_wait, NULL);
    abs_timeout.tv_sec = before_wait.tv_sec + TIMEOUT;
    abs_timeout.tv_nsec = before_wait.tv_usec * 1000;

    thread_state = ENTERED_THREAD;

    printf("thread: attempt timed write lock, %d seconds\n", TIMEOUT);
    rc = pthread_rwlock_timedwrlock(&rwlock, &abs_timeout);
    if (rc == 0)
    {
        printf("thread: correctly acquired write lock\n");
        expired = 0;
    }
    else if (rc == ETIMEDOUT)
    {
        printf("thread: timer expired, did not acquire write lock");
        expired = 1;
    }
    else
    {
        printf("Error %d at pthread_rwlock_timedwrlock()\n", rc);
        exit(PTS_UNRESOLVED);
    }

    gettimeofday(&after_wait, NULL);

    thread_state = EXITING_THREAD;
    pthread_exit(0);
    return NULL;
}
Example #20
0
static void *
writer (void *arg)
{
  struct timespec ts;
  if (clock_gettime (CLOCK_REALTIME, &ts) != 0)
    {
      puts ("clock_gettime failed");
      exit (EXIT_FAILURE);
    }
  ts.tv_sec += 1;
  int e = pthread_rwlock_timedwrlock (&r, &ts);
  if (e != ETIMEDOUT)
    {
      puts ("timedwrlock did not time out");
      exit (EXIT_FAILURE);
    }
  return NULL;
}
Example #21
0
lagopus_result_t
lagopus_rwlock_writer_timedlock(lagopus_rwlock_t *rwlptr,
                                lagopus_chrono_t nsec) {
  lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;

  if (rwlptr != NULL &&
      *rwlptr != NULL) {
    int st;

    if (nsec < 0) {
      if ((st = pthread_rwlock_wrlock(&((*rwlptr)->m_rwl))) == 0) {
        (*rwlptr)->m_prev_cancel_state = -INT_MAX;
        ret = LAGOPUS_RESULT_OK;
      } else {
        errno = st;
        ret = LAGOPUS_RESULT_POSIX_API_ERROR;
      }
    } else {
      struct timespec ts;
      lagopus_chrono_t now;

      WHAT_TIME_IS_IT_NOW_IN_NSEC(now);
      now += nsec;
      NSEC_TO_TS(now, ts);

      if ((st = pthread_rwlock_timedwrlock(&((*rwlptr)->m_rwl),
                                           &ts)) == 0) {
        (*rwlptr)->m_prev_cancel_state = -INT_MAX;
        ret = LAGOPUS_RESULT_OK;
      } else {
        errno = st;
        if (st == ETIMEDOUT) {
          ret = LAGOPUS_RESULT_TIMEDOUT;
        } else {
          ret = LAGOPUS_RESULT_POSIX_API_ERROR;
        }
      }
    }
  } else {
    ret = LAGOPUS_RESULT_INVALID_ARGS;
  }

  return ret;
}
Example #22
0
File: 5-1.c Project: Nan619/ltp-ddt
static void *fn_wr_1(void *arg)
{
	thread_state = ENTERED_THREAD;
	struct timespec abs_timeout;
	int rc;
	pthread_rwlock_t rwlock;

	if (pthread_rwlock_init(&rwlock, NULL) != 0) {
		printf("thread1: Error at pthread_rwlock_init\n");
		exit(PTS_UNRESOLVED);
	}

	currsec1 = time(NULL);

	/* Absolute time, not relative. */
	abs_timeout.tv_sec = currsec1 + TIMEOUT;
	abs_timeout.tv_nsec = 0;

	printf("thread1: attempt timed lock for writing\n");
	rc = pthread_rwlock_timedwrlock(&rwlock, &abs_timeout);
	if (rc == ETIMEDOUT) {
		printf("thread1: timer expired\n");
		expired = 1;
	} else if (rc == 0) {
		printf("thread1: acquired write lock\n");
		expired = 0;
		printf("thread1: unlock write lock\n");
		if (pthread_rwlock_unlock(&rwlock) != 0) {
			printf("thread1: failed to release write lock\n");
			exit(PTS_UNRESOLVED);
		}
	} else {
		printf("thread1: Error in pthread_rwlock_timedwrlock().\n");
		exit(PTS_UNRESOLVED);
	}

	if (pthread_rwlock_destroy(&rwlock) != 0) {
		printf("thread1: Error at pthread_rwlockattr_destroy()");
		exit(PTS_UNRESOLVED);
	}
	thread_state = EXITING_THREAD;
	pthread_exit(0);
	return NULL;
}
Example #23
0
LIB_EXPORT rc_t CC KRWLockTimedAcquireExcl ( KRWLock *self, timeout_t *tm )
{
    int status;

    if ( self == NULL )
        return RC ( rcPS, rcRWLock, rcLocking, rcSelf, rcNull );

    status = pthread_rwlock_trywrlock ( & self -> lock );
    switch ( status )
    {
    case 0:
        return 0;
    case EBUSY:
        if ( tm != NULL )
            break;
        return RC ( rcPS, rcRWLock, rcLocking, rcLock, rcBusy );
    case EINVAL:
        return RC ( rcPS, rcRWLock, rcLocking, rcRWLock, rcInvalid );
    default:
        return RC ( rcPS, rcRWLock, rcLocking, rcNoObj, rcUnknown );
    }

    if ( ! tm -> prepared )
        TimeoutPrepare ( tm );

    status = pthread_rwlock_timedwrlock ( & self -> lock, & tm -> ts );
    switch ( status )
    {
    case 0:
        break;
    case ETIMEDOUT:
        return RC ( rcPS, rcRWLock, rcLocking, rcTimeout, rcExhausted );
    case EDEADLK:
        return RC ( rcPS, rcRWLock, rcLocking, rcThread, rcDeadlock );
    case EINVAL:
        return RC ( rcPS, rcRWLock, rcLocking, rcTimeout, rcInvalid );
    default:
        return RC ( rcPS, rcRWLock, rcLocking, rcNoObj, rcUnknown );
    }

    return 0;
}
Example #24
0
int
main()
{
  pthread_t t;
  struct timespec abstime, reltime = { 1, 0 };

  (void) pthread_win32_getabstime_np(&abstime, &reltime);

  assert(pthread_rwlock_timedwrlock(&rwlock1, &abstime) == 0);

  assert(pthread_create(&t, NULL, func, NULL) == 0);

  Sleep(2000);

  assert(pthread_rwlock_unlock(&rwlock1) == 0);

  assert(washere == 1);

  return 0;
}
Example #25
0
void * wrfunc(void * arg)
{
  int result;

  result = pthread_rwlock_timedwrlock(&rwlock1, &abstime);
  if ((int) (size_t)arg == 1)
    {
      assert(result == 0);
      Sleep(2000);
      bankAccount += 10;
      assert(pthread_rwlock_unlock(&rwlock1) == 0);
      return ((void *)(size_t)bankAccount);
    }
  else if ((int) (size_t)arg == 2)
    {
      assert(result == ETIMEDOUT);
      return ((void *) 100);
    }

  return ((void *)(size_t)-1);
}
Example #26
0
bool ReadWriteLock::BeginWriteTimeout(long milliseconds)
{
#if defined(MEDUSA_ANDROID)||defined(MEDUSA_IOS)
	const int sleepMillis = 5;
	StopWatch watch;
	watch.Start();
	do
	{
		RETURN_TRUE_IF_TRUE(TryBeginWrite());
		Thread::Sleep(sleepMillis);
		watch.Shot();
	} while (watch.ElapsedMilliseconds() < milliseconds);
	return false;

#else
	struct timespec abstime = PerformanceCounter::ToAbsoluteTime(milliseconds);
	int result = pthread_rwlock_timedwrlock(&mLock, &abstime);
	return result == 0;
#endif

}
Example #27
0
File: init.c Project: Fyleo/rtems
void *Middle(
  void *argument
)
{
  int status;

  /*
   * Now we have finished the thread startup overhead,
   * so let other threads run.  When we return, we can
   * finish the benchmark.
   */
  sched_yield();
    /* let other threads run */

  /* This timed write lock operation will be blocked 
   * because the other write operation has the lock
   */
    status = pthread_rwlock_timedwrlock(&rwlock, &abstime);
  rtems_test_assert( status == 0 );
  return NULL;
}
Example #28
0
DWORD
VmDirRWLockWriteLock(
    PVMDIR_RWLOCK   pLock,
    DWORD           dwMilliSec
    )
{
#ifdef __APPLE__
    return VMDIR_ERROR_OPERATION_NOT_PERMITTED;
#else
    DWORD dwError = 0;

    if (!pLock || !pLock->bInitialized)
    {
        dwError = VMDIR_ERROR_INVALID_PARAMETER;
        BAIL_ON_VMDIR_ERROR(dwError);
    }

    if (dwMilliSec)
    {
        struct timespec ts = {0};
        uint64_t iTimeInMSec = 0;

        iTimeInMSec =  dwMilliSec + VmDirGetTimeInMilliSec();
        ts.tv_sec = iTimeInMSec / MSECS_PER_SEC;
        ts.tv_nsec = (iTimeInMSec % MSECS_PER_SEC) * NSECS_PER_MSEC;

        dwError = pthread_rwlock_timedwrlock(&pLock->lock, &ts);
        BAIL_ON_VMDIR_ERROR(dwError);
    }
    else
    {
        dwError = pthread_rwlock_wrlock(&pLock->lock);
        BAIL_ON_VMDIR_ERROR(dwError);
    }

error:
    return dwError;
#endif
}
Example #29
0
int __ast_rwlock_timedwrlock(const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name,
	const struct timespec *abs_timeout)
{
	int res;

#ifdef DEBUG_THREADS
	struct ast_lock_track *lt;
	int canlog = strcmp(filename, "logger.c") & t->tracking;
#ifdef HAVE_BKTR
	struct ast_bt *bt = NULL;
#endif

#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
	if ((t->lock) == ((pthread_rwlock_t) __AST_RWLOCK_INIT_VALUE)) {
		 /* Don't warn abount uninitialized lock.
		  * Simple try to initialize it.
		  * May be not needed in linux system.
		  */
		res = __ast_rwlock_init(t->tracking, filename, line, func, name, t);
		if ((t->lock) == ((pthread_rwlock_t) __AST_RWLOCK_INIT_VALUE)) {
			__ast_mutex_logger("%s line %d (%s): Error: rwlock '%s' is uninitialized and unable to initialize.\n",
					filename, line, func, name);
			return res;
		}
	}
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */

	if (t->tracking && !t->track) {
		ast_reentrancy_init(&t->track);
	}
	lt = t->track;

	if (t->tracking) {
#ifdef HAVE_BKTR
		ast_reentrancy_lock(lt);
		if (lt->reentrancy != AST_MAX_REENTRANCY) {
			ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
			bt = &lt->backtrace[lt->reentrancy];
		}
		ast_reentrancy_unlock(lt);
		ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t, bt);
#else
		ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t);
#endif
	}
#endif /* DEBUG_THREADS */

#ifdef HAVE_PTHREAD_RWLOCK_TIMEDWRLOCK
	res = pthread_rwlock_timedwrlock(&t->lock, abs_timeout);
#else
	do {
		struct timeval _start = ast_tvnow(), _diff;
		for (;;) {
			if (!(res = pthread_rwlock_trywrlock(&t->lock))) {
				break;
			}
			_diff = ast_tvsub(ast_tvnow(), _start);
			if (_diff.tv_sec > abs_timeout->tv_sec || (_diff.tv_sec == abs_timeout->tv_sec && _diff.tv_usec * 1000 > abs_timeout->tv_nsec)) {
				break;
			}
			usleep(1);
		}
	} while (0);
#endif

#ifdef DEBUG_THREADS
	if (!res && t->tracking) {
		ast_reentrancy_lock(lt);
		if (lt->reentrancy < AST_MAX_REENTRANCY) {
			lt->file[lt->reentrancy] = filename;
			lt->lineno[lt->reentrancy] = line;
			lt->func[lt->reentrancy] = func;
			lt->thread[lt->reentrancy] = pthread_self();
			lt->reentrancy++;
		}
		ast_reentrancy_unlock(lt);
		if (t->tracking) {
			ast_mark_lock_acquired(t);
		}
	} else if (t->tracking) {
#ifdef HAVE_BKTR
		if (lt->reentrancy) {
			ast_reentrancy_lock(lt);
			bt = &lt->backtrace[lt->reentrancy-1];
			ast_reentrancy_unlock(lt);
		} else {
			bt = NULL;
		}
		if (t->tracking) {
			ast_remove_lock_info(t, bt);
		}
#else
		if (t->tracking) {
			ast_remove_lock_info(t);
		}
#endif
	}
	if (res) {
		__ast_mutex_logger("%s line %d (%s): Error obtaining read lock: %s\n",
				filename, line, func, strerror(res));
		DO_THREAD_CRASH;
	}
#endif /* DEBUG_THREADS */

	return res;
}
Example #30
0
DECL_FORCE_INLINE(int) rtSemRWRequestWrite(RTSEMRW hRWSem, RTMSINTERVAL cMillies, PCRTLOCKVALSRCPOS pSrcPos)
{
    /*
     * Validate input.
     */
    struct RTSEMRWINTERNAL *pThis = hRWSem;
    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
    AssertMsgReturn(pThis->u32Magic == RTSEMRW_MAGIC,
                    ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic),
                    VERR_INVALID_HANDLE);

    /*
     * Recursion?
     */
    pthread_t Self = pthread_self();
    pthread_t Writer;
    ATOMIC_GET_PTHREAD_T(&pThis->Writer, &Writer);
    if (Writer == Self)
    {
#ifdef RTSEMRW_STRICT
        int rc9 = RTLockValidatorRecExclRecursion(&pThis->ValidatorWrite, pSrcPos);
        if (RT_FAILURE(rc9))
            return rc9;
#endif
        Assert(pThis->cWrites < INT32_MAX);
        pThis->cWrites++;
        return VINF_SUCCESS;
    }

    /*
     * Try lock it.
     */
    RTTHREAD hThreadSelf = NIL_RTTHREAD;
    if (cMillies)
    {
#ifdef RTSEMRW_STRICT
        hThreadSelf = RTThreadSelfAutoAdopt();
        int rc9 = RTLockValidatorRecExclCheckOrderAndBlocking(&pThis->ValidatorWrite, hThreadSelf, pSrcPos, true,
                                                              cMillies, RTTHREADSTATE_RW_WRITE, true);
        if (RT_FAILURE(rc9))
            return rc9;
#else
        hThreadSelf = RTThreadSelf();
        RTThreadBlocking(hThreadSelf, RTTHREADSTATE_RW_WRITE, true);
#endif
    }

    if (cMillies == RT_INDEFINITE_WAIT)
    {
        /* take rwlock */
        int rc = pthread_rwlock_wrlock(&pThis->RWLock);
        RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_RW_WRITE);
        if (rc)
        {
            AssertMsgFailed(("Failed write lock read-write sem %p, rc=%d.\n", hRWSem, rc));
            return RTErrConvertFromErrno(rc);
        }
    }
    else
    {
#ifdef RT_OS_DARWIN
        AssertMsgFailed(("Not implemented on Darwin yet because of incomplete pthreads API."));
        return VERR_NOT_IMPLEMENTED;
#else /* !RT_OS_DARWIN */
        /*
         * Get current time and calc end of wait time.
         */
        struct timespec     ts = {0,0};
        clock_gettime(CLOCK_REALTIME, &ts);
        if (cMillies != 0)
        {
            ts.tv_nsec += (cMillies % 1000) * 1000000;
            ts.tv_sec  += cMillies / 1000;
            if (ts.tv_nsec >= 1000000000)
            {
                ts.tv_nsec -= 1000000000;
                ts.tv_sec++;
            }
        }

        /* take rwlock */
        int rc = pthread_rwlock_timedwrlock(&pThis->RWLock, &ts);
        RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_RW_WRITE);
        if (rc)
        {
            AssertMsg(rc == ETIMEDOUT, ("Failed read lock read-write sem %p, rc=%d.\n", hRWSem, rc));
            return RTErrConvertFromErrno(rc);
        }
#endif /* !RT_OS_DARWIN */
    }

    ATOMIC_SET_PTHREAD_T(&pThis->Writer, Self);
    pThis->cWrites = 1;
    Assert(!pThis->cReaders);
#ifdef RTSEMRW_STRICT
    RTLockValidatorRecExclSetOwner(&pThis->ValidatorWrite, hThreadSelf, pSrcPos, true);
#endif
    return VINF_SUCCESS;
}