Changeset 53c6e6a in mainline

Timestamp:

2018-07-05T21:41:20Z (7 years ago)

Author:

Dzejrou <dzejrou@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

b4b961b

Parents:

ce22ac6

git-author:

Dzejrou <dzejrou@…> (2018-03-29 14:13:16)

git-committer:

Dzejrou <dzejrou@…> (2018-07-05 21:41:20)

Message:

cpp: added shared_lock and lock()

File:

• uspace/lib/cpp/include/impl/mutex.hpp (modified) (2 diffs)

uspace/lib/cpp/include/impl/mutex.hpp

@@ -387 +387 @@
             }
 
-            void unlock();
+            void unlock()
             {
                 /**
@@ -450 +450 @@
      */
 
-    // TODO:
     template<class Mutex>
-    class shared_lock;
+    class shared_lock
+    {
+        public:
+            using mutex_type = Mutex;
+
+            /**
+             * 30.4.2.2.1, construction/copy/destroy:
+             */
+
+            shared_lock() noexcept
+                : mtx_{nullptr}, owns_{false}
+            { /* DUMMY BODY */ }
+
+            explicit shared_lock(mutex_type& mtx)
+                : mtx_{&mtx}, owns_{true}
+            {
+                mtx_->lock_shared();
+            }
+
+            shared_lock(mutex_type& mtx, defer_lock_t) noexcept
+                : mtx_{&mtx}, owns_{false}
+            { /* DUMMY BODY */ }
+
+            shared_lock(mutex_type& mtx, try_to_lock_t)
+                : mtx_{&mtx}, owns_{}
+            {
+                owns_ = mtx_->try_lock_shared();
+            }
+
+            shared_lock(mutex_type& mtx, adopt_lock_t)
+                : mtx_{&mtx}, owns_{true}
+            { /* DUMMY BODY */ }
+
+            template<class Clock, class Duration>
+            shared_lock(mutex_type& mtx, const chrono::time_point<Clock, Duration>& abs_time)
+                : mtx_{&mtx}, owns_{}
+            {
+                owns_ = mtx_->try_lock_shared_until(abs_time);
+            }
+
+            template<class Rep, class Period>
+            shared_lock(mutex_type& mtx, const chrono::duration<Rep, Period>& rel_time)
+                : mtx_{&mtx}, owns_{}
+            {
+                owns_ = mtx_->try_lock_shared_for(rel_time);
+            }
+
+            ~shared_lock()
+            {
+                if (owns_)
+                    mtx_->unlock_shared();
+            }
+
+            shared_lock(const shared_lock&) = delete;
+            shared_lock& operator=(const shared_lock&) = delete;
+
+            shared_lock(shared_lock&& other) noexcept
+                : mtx_{move(other.mtx_)}, owns_{move(other.owns_)}
+            {
+                other.mtx_ = nullptr;
+                other.owns_ = false;
+            }
+
+            shared_lock& operator=(shared_lock&& other)
+            {
+                if (owns_)
+                    mtx_->unlock_shared();
+
+                mtx_ = move(other.mtx_);
+                owns_ = move(other.owns_);
+
+                other.mtx_ = nullptr;
+                other.owns_ = false;
+            }
+
+            /**
+             * 30.4.2.2.2, locking:
+             */
+
+            void lock()
+            {
+                /**
+                 * TODO:
+                 * throw system_error operation_not_permitted if mtx_ == nullptr
+                 * throw system_error resource_deadlock_would_occur if owns_ == true
+                 */
+
+                mtx_->lock_shared();
+                owns_ = true;
+            }
+
+            bool try_lock()
+            {
+                /**
+                 * TODO:
+                 * throw system_error operation_not_permitted if mtx_ == nullptr
+                 * throw system_error resource_deadlock_would_occur if owns_ == true
+                 */
+
+                owns_ = mtx_->try_lock_shared();
+
+                return owns_;
+            }
+
+            template<class Rep, class Period>
+            bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
+            {
+                /**
+                 * TODO:
+                 * throw system_error operation_not_permitted if mtx_ == nullptr
+                 * throw system_error resource_deadlock_would_occur if owns_ == true
+                 */
+
+                owns_ = mtx_->try_lock_shared_for(rel_time);
+
+                return owns_;
+            }
+
+            template<class Clock, class Duration>
+            bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
+            {
+                /**
+                 * TODO:
+                 * throw system_error operation_not_permitted if mtx_ == nullptr
+                 * throw system_error resource_deadlock_would_occur if owns_ == true
+                 */
+
+                owns_ = mtx_->try_lock_shared_until(abs_time);
+
+                return owns_;
+            }
+
+            void unlock()
+            {
+                /**
+                 * TODO:
+                 * throw system_error operation_not_permitted if owns_ == false
+                 */
+
+                mtx_->unlock_shared();
+            }
+
+            /**
+             * 30.4.2.2.3, modifiers:
+             */
+
+            void swap(shared_lock& other) noexcept
+            {
+                std::swap(mtx_, other.mtx_);
+                std::swap(owns_, other.owns_);
+            }
+
+            mutex_type* release() noexcept
+            {
+                auto ret = mtx_;
+                mtx_ = nullptr;
+                owns_ = false;
+
+                return ret;
+            }
+
+            /**
+             * 30.4.2.2.4, observers:
+             */
+
+            bool owns_lock() const noexcept
+            {
+                return owns_;
+            }
+
+            explicit operator bool() const noexcept
+            {
+                return owns_;
+            }
+
+            mutex_type* mutex() const noexcept
+            {
+                return mtx_;
+            }
+
+        private:
+            mutex_type* mtx_;
+            bool owns_;
+    };
 
     template<class Mutex>
-    void swap(shared_lock<Mutex>& lhs, shared_lock<Mutex>& rhs) noexcept;
+    void swap(shared_lock<Mutex>& lhs, shared_lock<Mutex>& rhs) noexcept
+    {
+        lhs.swap(rhs);
+    }
 
     template<class L1, class L2, class... L3>
     int try_lock(L1& l1, L2& l2, L3&... ls);
 
+    namespace aux
+    {
+        template<class L>
+        bool lock_tail(L& l)
+        {
+            return l.try_lock();
+        }
+
+        template<class L1, class... L2>
+        bool lock_tail(L1& l1, L2&... ls)
+        {
+            if (l1.try_lock())
+            {
+                auto ret = lock_tail(ls...);
+                if (ret)
+                    return true;
+
+                l1.unlock();
+            }
+
+            return false;
+        }
+    }
+
     template<class L1, class L2, class... L3>
-    void lock(L1& l1, L2& l2, L3&... ls);
+    void lock(L1& l1, L2& l2, L3&... ls)
+    {
+        do
+        {
+            l1.lock();
+
+            if (aux::lock_tail(l2, ls...))
+                return;
+            l1.unlock();
+        } while (true);
+    }
 
     struct once_flag