0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-11-18 07:50:57 +01:00
construct/include/ircd/ctx/mutex.h

149 lines
2.2 KiB
C
Raw Normal View History

2018-02-04 03:22:01 +01:00
// Matrix Construct
//
// Copyright (C) Matrix Construct Developers, Authors & Contributors
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice is present in all copies. The
// full license for this software is available in the LICENSE file.
2016-09-19 07:43:24 +02:00
#pragma once
#define HAVE_IRCD_CTX_MUTEX_H
namespace ircd::ctx
{
class mutex;
}
2016-09-19 07:43:24 +02:00
//
// The mutex only allows one context to lock it and continue,
// additional contexts are queued. This can be used with std::
// locking concepts.
//
class ircd::ctx::mutex
2016-09-19 07:43:24 +02:00
{
dock q;
bool m;
2016-09-19 07:43:24 +02:00
public:
bool locked() const;
size_t waiting() const;
2016-09-19 07:43:24 +02:00
bool try_lock();
template<class time_point> bool try_lock_until(const time_point &);
template<class duration> bool try_lock_for(const duration &);
void lock();
void unlock();
mutex();
mutex(mutex &&) noexcept;
mutex(const mutex &) = delete;
mutex &operator=(mutex &&) noexcept;
mutex &operator=(const mutex &) = delete;
2016-09-19 07:43:24 +02:00
~mutex() noexcept;
};
inline
ircd::ctx::mutex::mutex()
:m{false}
2016-09-19 07:43:24 +02:00
{
}
inline
ircd::ctx::mutex::mutex(mutex &&o)
noexcept
:q{std::move(o.q)}
,m{std::move(o.m)}
{
o.m = false;
}
inline
ircd::ctx::mutex &
ircd::ctx::mutex::operator=(mutex &&o)
noexcept
{
this->~mutex();
q = std::move(o.q);
m = std::move(o.m);
o.m = false;
return *this;
}
2016-09-19 07:43:24 +02:00
inline
ircd::ctx::mutex::~mutex()
2016-09-19 07:43:24 +02:00
noexcept
{
assert(!m);
}
inline void
ircd::ctx::mutex::unlock()
2016-09-19 07:43:24 +02:00
{
assert(m);
2016-09-19 07:43:24 +02:00
m = false;
q.notify_one();
2016-09-19 07:43:24 +02:00
}
inline void
ircd::ctx::mutex::lock()
2016-09-19 07:43:24 +02:00
{
q.wait([this]
{
return !locked();
});
2016-09-19 07:43:24 +02:00
m = true;
2016-09-19 07:43:24 +02:00
}
template<class duration>
bool
ircd::ctx::mutex::try_lock_for(const duration &d)
2016-09-19 07:43:24 +02:00
{
return try_lock_until(steady_clock::now() + d);
}
template<class time_point>
bool
ircd::ctx::mutex::try_lock_until(const time_point &tp)
2016-09-19 07:43:24 +02:00
{
const bool success
2016-09-19 07:43:24 +02:00
{
q.wait_until(tp, [this]
2016-09-19 07:43:24 +02:00
{
return !locked();
})
};
2016-09-19 07:43:24 +02:00
if(likely(success))
m = true;
return success;
2016-09-19 07:43:24 +02:00
}
inline bool
ircd::ctx::mutex::try_lock()
2016-09-19 07:43:24 +02:00
{
if(locked())
2016-09-19 07:43:24 +02:00
return false;
m = true;
return true;
}
inline size_t
ircd::ctx::mutex::waiting()
const
{
return q.size();
}
inline bool
ircd::ctx::mutex::locked()
const
{
return m;
}