git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

mutex (mutex::mutex): Fix usage of initializing macro. 

2008-05-06  Benjamin Kosnik  <bkoz@redhat.com>

	* include/std/mutex (mutex::mutex): Fix usage of initializing macro.
	(recursive_mutex::recursive_mutex): Same.
	(once_flag::once_flag): Same.
	* testsuite/30_threads/mutex/cons/assign_neg.cc: Fix line numbers.
	* testsuite/30_threads/mutex/cons/copy_neg.cc: Same.
	* testsuite/30_threads/recursive_mutex/cons/assign_neg.cc: Same.
	* testsuite/30_threads/recursive_mutex/cons/copy_neg.cc: Same.

From-SVN: r135015
This commit is contained in:
Benjamin Kosnik 2008-05-07 00:55:51 +00:00 committed by Benjamin Kosnik
parent 77fa554dfc
commit 4db6bc0f6e
6 changed files with 90 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,13 @@
2008-05-06 Benjamin Kosnik <bkoz@redhat.com>
* include/std/mutex (mutex::mutex): Fix usage of initializing macro.
(recursive_mutex::recursive_mutex): Same.
(once_flag::once_flag): Same.
* testsuite/30_threads/mutex/cons/assign_neg.cc: Fix line numbers.
* testsuite/30_threads/mutex/cons/copy_neg.cc: Same.
* testsuite/30_threads/recursive_mutex/cons/assign_neg.cc: Same.
* testsuite/30_threads/recursive_mutex/cons/copy_neg.cc: Same.
2008-05-06 Benjamin Kosnik <bkoz@redhat.com>
* include/std/condition_variable: New.

152
libstdc++-v3/include/std/mutex
View File

@ -1,6 +1,6 @@
// <mutex> -*- C++ -*-
// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
@ -44,9 +44,9 @@
#include <exception>
#include <cstddef>
#include <bits/functexcept.h>
#include <bits/gthr.h>
#include <bits/gthr.h>
namespace std
namespace std
{
// XXX
class system_time;
@ -63,47 +63,45 @@ namespace std
native_handle_type __tmp = __GTHREAD_MUTEX_INIT;
_M_mutex = __tmp;
#else
int __e = __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex);
__GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex);
#endif
// EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may)
if ( __e)
__throw_system_error(__e);
#endif
}
void
void
lock()
{
int __e = __gthread_mutex_lock(&_M_mutex);
// EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
if ( __e)
if (__e)
__throw_system_error(__e);
}
bool
bool
try_lock()
{
int __e = __gthread_mutex_trylock(&_M_mutex);
// EINVAL, EAGAIN, EBUSY
if ( __e)
if (__e)
__throw_system_error(__e);
else
return true;
}
void
void
unlock()
{
int __e = __gthread_mutex_unlock(&_M_mutex);
// EINVAL, EAGAIN, EPERM
if ( __e)
if (__e)
__throw_system_error(__e);
}
native_handle_type
native_handle_type
native_handle()
{ return _M_mutex; }
@ -121,53 +119,51 @@ namespace std
typedef __gthread_recursive_mutex_t native_handle_type;
recursive_mutex()
{
{
#if defined __GTHREAD_RECURSIVE_MUTEX_INIT
native_handle_type __tmp = __GTHREAD_RECURSIVE_MUTEX_INIT;
_M_mutex = __tmp;
#else
int __e = __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex);
__GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex);
#endif
// EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may)
if ( __e)
__throw_system_error(__e);
#endif
}
void
void
lock()
{
{
int __e = __gthread_recursive_mutex_lock(&_M_mutex);
// EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
if ( __e)
if (__e)
__throw_system_error(__e);
}
bool
bool
try_lock()
{
int __e = __gthread_recursive_mutex_trylock(&_M_mutex);
// EINVAL, EAGAIN, EBUSY
if ( __e)
if (__e)
__throw_system_error(__e);
else
return true;
}
void
void
unlock()
{
{
int __e = __gthread_recursive_mutex_unlock(&_M_mutex);
// EINVAL, EAGAIN, EBUSY
if ( __e)
if (__e)
__throw_system_error(__e);
}
native_handle_type
native_handle_type
native_handle() { return _M_mutex; }
private:
@ -191,22 +187,22 @@ namespace std
/// and manage it.
struct adopt_lock_t { };
extern const defer_lock_t defer_lock;
extern const try_to_lock_t try_to_lock;
extern const adopt_lock_t adopt_lock;
extern const defer_lock_t defer_lock;
extern const try_to_lock_t try_to_lock;
extern const adopt_lock_t adopt_lock;
/// Thrown to indicate errors with lock operations.
class lock_error : public exception
{
public:
virtual const char*
virtual const char*
what() const throw();
};
/// @brief Scoped lock idiom.
// Acquire the mutex here with a constructor call, then release with
// the destructor call in accordance with RAII style.
template<typename _Mutex>
template<typename _Mutex>
class lock_guard
{
public:
@ -228,7 +224,7 @@ namespace std
};
/// unique_lock
template<typename _Mutex>
template<typename _Mutex>
class unique_lock
{
public:
@ -237,18 +233,18 @@ namespace std
unique_lock() : _M_device(NULL), _M_owns(false) { }
explicit unique_lock(mutex_type& __m) : _M_device(&__m)
{
lock();
{
lock();
_M_owns = true;
}
unique_lock(mutex_type& __m, defer_lock_t)
unique_lock(mutex_type& __m, defer_lock_t)
: _M_device(&__m), _M_owns(false) { }
unique_lock(mutex_type& __m, try_to_lock_t)
unique_lock(mutex_type& __m, try_to_lock_t)
: _M_device(&__m), _M_owns(_M_device->try_lock()) { }
unique_lock(mutex_type& __m, adopt_lock_t)
unique_lock(mutex_type& __m, adopt_lock_t)
: _M_device(&__m), _M_owns(true)
{
// XXX calling thread owns mutex
@ -257,7 +253,7 @@ namespace std
unique_lock(mutex_type& __m, const system_time& abs_time);
template<typename _Duration>
unique_lock(mutex_type& __m, const _Duration& rel_time);
unique_lock(mutex_type& __m, const _Duration& rel_time);
~unique_lock()
{
@ -270,60 +266,60 @@ namespace std
unique_lock& operator=(unique_lock&&);
void
void
lock()
{
{
if (_M_device && !_M_owns)
_M_device->lock();
_M_device->lock();
else
throw lock_error();
}
bool
bool
try_lock()
{
{
bool __ret = false;
if (_M_device && !_M_owns)
__ret = _M_device->try_lock();
__ret = _M_device->try_lock();
else
throw lock_error();
return __ret;
}
void
void
unlock()
{
{
if (_M_device && _M_owns)
_M_device->unlock();
_M_device->unlock();
else
throw lock_error();
}
template<typename _Duration>
bool timed_lock(const _Duration& rel_time);
bool timed_lock(const _Duration& rel_time);
bool
bool
timed_lock(const system_time& abs_time);
void
void
swap(unique_lock&& __u);
mutex_type*
release()
{
mutex_type* __ret = _M_device;
mutex_type*
release()
{
mutex_type* __ret = _M_device;
_M_device = NULL;
_M_owns = false;
return __ret;
}
bool
bool
owns_lock() const { return _M_owns; }
operator bool () const { return owns_lock(); }
mutex_type*
mutex_type*
mutex() const
{ return _M_device; }
@ -331,36 +327,40 @@ namespace std
unique_lock(unique_lock const&);
unique_lock& operator=(unique_lock const&);
mutex_type* _M_device;
bool _M_owns; // XXX use atomic_bool
mutex_type* _M_device;
bool _M_owns; // XXX use atomic_bool
};
template<typename _Mutex>
void
void
swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y);
template<typename _Mutex>
void
void
swap(unique_lock<_Mutex>&& __x, unique_lock<_Mutex>& __y);
template<typename _Mutex>
void
void
swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>&& __y);
template<typename _L1, typename _L2, typename ..._L3>
int
template<typename _L1, typename _L2, typename ..._L3>
int
try_lock(_L1&, _L2&, _L3&...);
template<typename _L1, typename _L2, typename ..._L3>
void
template<typename _L1, typename _L2, typename ..._L3>
void
lock(_L1&, _L2&, _L3&...);
/// once_flag
struct once_flag
struct once_flag
{
typedef __gthread_once_t __native_type;
once_flag() : _M_once(__GTHREAD_ONCE_INIT) { }
once_flag()
{
__native_type __tmp = __GTHREAD_ONCE_INIT;
_M_once = __tmp;
}
__native_type&
_M_get() { return _M_once; }
@ -372,11 +372,11 @@ namespace std
};
template<typename _Callable, typename... _Args>
void
void
call_once(once_flag& __once, _Callable __f, _Args&&... __args)
{
int __e = __gthread_once(&(__once._M_get()), __f(__args...));
if ( __e)
int __e = __gthread_once(&(__once._M_get()), __f(__args...));
if (__e)
__throw_system_error(__e);
}
}

2
libstdc++-v3/testsuite/30_threads/mutex/cons/assign_neg.cc
View File

@ -39,4 +39,4 @@ void test01()
m1 = m2;
}
// { dg-error "within this context" "" { target *-*-* } 39 }
// { dg-error "is private" "" { target *-*-* } 113 }
// { dg-error "is private" "" { target *-*-* } 111 }

2
libstdc++-v3/testsuite/30_threads/mutex/cons/copy_neg.cc
View File

@ -38,4 +38,4 @@ void test01()
mutex_type m2(m1);
}
// { dg-error "within this context" "" { target *-*-* } 38 }
// { dg-error "is private" "" { target *-*-* } 112 }
// { dg-error "is private" "" { target *-*-* } 110 }

2
libstdc++-v3/testsuite/30_threads/recursive_mutex/cons/assign_neg.cc
View File

@ -39,4 +39,4 @@ void test01()
m1 = m2;
}
// { dg-error "within this context" "" { target *-*-* } 39 }
// { dg-error "is private" "" { target *-*-* } 177 }
// { dg-error "is private" "" { target *-*-* } 173 }

2
libstdc++-v3/testsuite/30_threads/recursive_mutex/cons/copy_neg.cc
View File

@ -38,4 +38,4 @@ void test01()
mutex_type m2(m1);
}
// { dg-error "within this context" "" { target *-*-* } 38 }
// { dg-error "is private" "" { target *-*-* } 176 }
// { dg-error "is private" "" { target *-*-* } 172 }