Пример #1
0
Error RWLockPosix::write_try_lock() {
	if (pthread_rwlock_trywrlock(&rwlock) != 0) {
		return ERR_BUSY;
	} else {
		return OK;
	}
}
Пример #2
0
bool TRI_TryWriteLockReadWriteLock (TRI_read_write_lock_t* lock) {
  int rc;

  rc = pthread_rwlock_trywrlock(lock);

  return (rc == 0);
}
Пример #3
0
int PlatformRWTryWLock(RWLock lock) {
#ifndef WIN32
   pthread_rwlock_t *l = lock;
   return pthread_rwlock_trywrlock(l);
#else
#endif
}
Пример #4
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;
}
Пример #5
0
 bool RWLock::try_write_lock()
 {
     IMPL(impl);
     if (pthread_rwlock_trywrlock(&impl->rwlock) == 0)
         return true;
     return false;
 }
Пример #6
0
bool
cThreadLockRw::TryWriteLock()
{
  int rv = pthread_rwlock_trywrlock( &m_rwlock );

  return rv == 0;
}
Пример #7
0
static void *trywrlock(void *arg)
{
	int r = pthread_rwlock_trywrlock(arg);
	if (r != EBUSY)
		t_error("trywrlock for rdlocked lock returned %s, want EBUSY\n", strerror(r));
	return 0;
}
Пример #8
0
wi_boolean_t wi_rwlock_trywrlock(wi_rwlock_t *lock) {
#ifdef WI_PTHREADS
	return (pthread_rwlock_trywrlock(&lock->rwlock) == 0);
#else
	return true;
#endif
}
Пример #9
0
TEST(pthread, pthread_rwlock_smoke) {
  pthread_rwlock_t l;
  ASSERT_EQ(0, pthread_rwlock_init(&l, NULL));

  // Single read lock
  ASSERT_EQ(0, pthread_rwlock_rdlock(&l));
  ASSERT_EQ(0, pthread_rwlock_unlock(&l));

  // Multiple read lock
  ASSERT_EQ(0, pthread_rwlock_rdlock(&l));
  ASSERT_EQ(0, pthread_rwlock_rdlock(&l));
  ASSERT_EQ(0, pthread_rwlock_unlock(&l));
  ASSERT_EQ(0, pthread_rwlock_unlock(&l));

  // Write lock
  ASSERT_EQ(0, pthread_rwlock_wrlock(&l));
  ASSERT_EQ(0, pthread_rwlock_unlock(&l));

  // Try writer lock
  ASSERT_EQ(0, pthread_rwlock_trywrlock(&l));
  ASSERT_EQ(EBUSY, pthread_rwlock_trywrlock(&l));
  ASSERT_EQ(EBUSY, pthread_rwlock_tryrdlock(&l));
  ASSERT_EQ(0, pthread_rwlock_unlock(&l));

  // Try reader lock
  ASSERT_EQ(0, pthread_rwlock_tryrdlock(&l));
  ASSERT_EQ(0, pthread_rwlock_tryrdlock(&l));
  ASSERT_EQ(EBUSY, pthread_rwlock_trywrlock(&l));
  ASSERT_EQ(0, pthread_rwlock_unlock(&l));
  ASSERT_EQ(0, pthread_rwlock_unlock(&l));

  // Try writer lock after unlock
  ASSERT_EQ(0, pthread_rwlock_wrlock(&l));
  ASSERT_EQ(0, pthread_rwlock_unlock(&l));

  // EDEADLK in "read after write"
  ASSERT_EQ(0, pthread_rwlock_wrlock(&l));
  ASSERT_EQ(EDEADLK, pthread_rwlock_rdlock(&l));
  ASSERT_EQ(0, pthread_rwlock_unlock(&l));

  // EDEADLK in "write after write"
  ASSERT_EQ(0, pthread_rwlock_wrlock(&l));
  ASSERT_EQ(EDEADLK, pthread_rwlock_wrlock(&l));
  ASSERT_EQ(0, pthread_rwlock_unlock(&l));

  ASSERT_EQ(0, pthread_rwlock_destroy(&l));
}
Пример #10
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
}
Пример #11
0
DLL_EXPORT int ptt_pthread_rwlock_trywrlock(RWLOCK *rwlock, char *loc)
{
int result;
    PTTRACE ("trywr before", rwlock, NULL, loc, PTT_MAGIC);
    result = pthread_rwlock_trywrlock(rwlock);
    PTTRACE ("trywr after", rwlock, NULL, loc, result);
    return result;
}
Пример #12
0
/// <summary>
/// Tries to acquire write lock (now). Returns true if succeeded, false if failed.
/// </summary>
/// <returns></returns>
bool RWLock::TryLockWrite()
{
#ifdef PLATFORM_WIN
	return (TryAcquireSRWLockExclusive( &mRwlock ) > 0);
#else
	return (pthread_rwlock_trywrlock( &mRwlock ) == 0);
#endif
}
Пример #13
0
void * func(void * arg)
{
  assert(pthread_rwlock_trywrlock(&rwlock1) == EBUSY);

  washere = 1;

  return 0; 
}
Пример #14
0
 try_write_locker(pthread_rwlock_t &lock)
   : L(lock), ok(false)
 {
   int rv = pthread_rwlock_trywrlock(&L);
   if(rv != 0 && rv != EBUSY)
     throw strerror_exception("Failed trying wrlock", rv);
   ok = (rv == 0);
 }
Пример #15
0
int __ast_rwlock_trywrlock(const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name)
{
	int res;

#ifdef DEBUG_THREADS
	struct ast_lock_track *lt = NULL;
#ifdef HAVE_BKTR
	struct ast_bt *bt = NULL;
#endif

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

	if (lt) {
#ifdef HAVE_BKTR
		struct ast_bt tmp;

		/* The implementation of backtrace() may have its own locks.
		 * Capture the backtrace outside of the reentrancy lock to
		 * avoid deadlocks. See ASTERISK-22455. */
		ast_bt_get_addresses(&tmp);

		ast_reentrancy_lock(lt);
		if (lt->reentrancy < AST_MAX_REENTRANCY) {
			lt->backtrace[lt->reentrancy] = tmp;
			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 */

	res = pthread_rwlock_trywrlock(&t->lock);

#ifdef DEBUG_THREADS
	if (!res && lt) {
		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);
		ast_mark_lock_acquired(t);
	} else if (lt) {
		ast_mark_lock_failed(t);
	}
#endif /* DEBUG_THREADS */

	return res;
}
Пример #16
0
int uv_rwlock_trywrlock(uv_rwlock_t* rwlock) {
  int err;

  err = pthread_rwlock_trywrlock(rwlock);
  if (err && err != EBUSY && err != EAGAIN)
    abort();

  return -err;
}
Пример #17
0
bool BufferFrame::tryLock(bool exclusive) {
	int result;
	if (exclusive){
		result = pthread_rwlock_trywrlock(&header.rwlock);
	}else{
		result = pthread_rwlock_tryrdlock(&header.rwlock);
	}
	return result == 0;
}
Пример #18
0
			bool TryLock(void) const
			{
				int ret = pthread_rwlock_trywrlock(&rwlock);

				DKASSERT_DESC_DEBUG(ret != EDEADLK, "The calling thread already owns the read/write lock.");
				DKASSERT_DESC_DEBUG(ret != EINVAL, "The value specified by rwlock is invalid.");
				DKASSERT_DESC_DEBUG(ret != ENOMEM, "Insufficient memory?");
				return ret == 0;
			}
Пример #19
0
void kl_pthread_rwlock_wrlock(void *data, bool tryOnly)
{
	if (tryOnly)
	{
		pthread_rwlock_trywrlock((pthread_rwlock_t *)data);
	} else {
		pthread_rwlock_wrlock((pthread_rwlock_t *)data);
	}
}
/******************************************************************************
函数名 :TryWriteLock
功能   :尝试对系统读写锁进行写加锁
输入   :无
输出   :无
返回值 :成功返回1,失败0
其他   :无
******************************************************************************/
int CRWLock::TryWriteLock()
{
	if (0 == pthread_rwlock_trywrlock(&m_rwlock))
	{
		return 1;
	}
	
	return 0;
}
Пример #21
0
int ldap_pvt_thread_rdwr_wtrylock( ldap_pvt_thread_rdwr_t *rw )
{
	int rc;
	LDAP_JITTER(25);
	rc = ERRVAL( pthread_rwlock_trywrlock( rw ) );
	LDAP_ENSURE(rc == 0 || rc == EBUSY);
	LDAP_JITTER(25);
	return rc;
}
Пример #22
0
static int lock_rwlock_trywrlock(lock_t * lock)
{
	if(NULL == lock)
	{
		dbg_printf("check the param\n");
		return(-1);
	}
	return pthread_rwlock_trywrlock(&lock->object.rwlock);
}
Пример #23
0
    bool RWMutex::TryLockWrite()
    {
#if defined(__WIN32__) || defined(WIN32)
      //return TryEnterCriticalSection(&handle)!=0;
      return false;
#elif defined(ILLUMINATION_THREAD_PTHREAD)
      return pthread_rwlock_trywrlock(&handle)==0;
#endif
    }
Пример #24
0
bool ReadWriteMutexImpl::tryWriteLock()
{
    int rc = pthread_rwlock_trywrlock(&_rwl);

    if( rc != 0 && rc != EBUSY)
        throw SystemError("pthread_rwlock_trywrlock failed");

    return rc != EBUSY;
}
Пример #25
0
bool rwlock_trywritelock(rwlock_t *rwlock)
{
    const int err = pthread_rwlock_trywrlock(rwlock);
    if (err == 0) return true;
    else if (err == EBUSY) return false;
    else {
        error("rwlock error: %s", errno_error(err));
        return false;
    }
}
Пример #26
0
int32_t 
el_rwlock_trywrlock(el_rwlock_t* rwlock)
{
  int ret = pthread_rwlock_trywrlock(rwlock);

  if (0 != ret && EBUSY != ret && EAGAIN != ret)
    abort();

  return (0 == ret ? EL_OK : EL_NO);
}
Пример #27
0
int
Pthread_rwlock_trywrlock(pthread_rwlock_t *rw)
{
	int		n;

	if ( (n = pthread_rwlock_trywrlock(rw)) != 0) {
		errno = n;
		err_sys("pthread_rwlock_trywrlock error");
	}
	return(n);
}
Пример #28
0
ce_int_t 
ce_thread_rwlock_trywrlock(ce_thread_rwlock_t *rwlock)
{
    ce_int_t st;

    st = pthread_rwlock_trywrlock(&rwlock->rwlock);
    /* Normalize the return code. */
    if (st == EBUSY)
        st = CE_EBUSY;
    return st;
}
Пример #29
0
int _wr_trylock(rwlock_t *lock, __maybe_unused const char *file, __maybe_unused const char *func, __maybe_unused const int line)
{
	int ret = pthread_rwlock_trywrlock(&lock->rwlock);

	if (!ret) {
		lock->file = file;
		lock->func = func;
		lock->line = line;
	}
	return ret;
}
Пример #30
0
 static void worker1(pthread_rwlock_t* lk, AtomicUInt32* x) {
     x->fetchAndAdd(1);  // 1
     cout << "lock b try" << endl;
     while (1) {
         if (pthread_rwlock_trywrlock(lk) == 0)
             break;
         sleepmillis(10);
     }
     cout << "lock b got" << endl;
     x->fetchAndAdd(1);  // 2
     pthread_rwlock_unlock(lk);
 }