Changeset 46c66f8 in mainline

Timestamp:

2019-07-07T12:59:11Z (5 years ago)

Author:

Jaroslav Jindrak <dzejrou@…>

Branches:

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

Children:

8c0b781

Parents:

8e24583

Message:

cpp: apply requested changes

Location:

uspace/lib/cpp

Files:

• include/__bits/thread/async.hpp (modified) (1 diff)
• include/__bits/thread/packaged_task.hpp (modified) (1 diff)
• include/__bits/thread/shared_state.hpp (modified) (10 diffs)
• src/__bits/runtime.cpp (modified) (2 diffs)
• src/__bits/test/future.cpp (modified) (2 diffs)

uspace/lib/cpp/include/__bits/thread/async.hpp

@@ -69 +69 @@
              * Note: The case when async | deferred is set in policy
              *       is implementation defined, feel free to change.
+             * Rationale: We chose the 'deferred' policy, because unlike
+             *            the 'async' policy it carries no possible
+             *            surprise ('async' can fail due to thread
+             *            creation error).
              */
             if (async && deferred)

uspace/lib/cpp/include/__bits/thread/packaged_task.hpp

@@ -45 +45 @@
      */
 
+    /**
+     * Note: The base template is not defined because
+     *       we require the template parameter to be
+     *       a callable object (e.g. a function). This
+     *       is achieved by the R(Args...) specialization
+     *       below.
+     */
     template<class>
-    class packaged_task; // undefined
+    class packaged_task;
 
     template<class R, class... Args>

uspace/lib/cpp/include/__bits/thread/shared_state.hpp

@@ -93 +93 @@
             }
 
-            /**
-             * TODO: This member function is supposed to be marked
-             *       as 'const'. In such a case, however, we cannot
-             *       use the underlying fibril API because these
-             *       references get converted to pointers and the API
-             *       does not accept e.g. 'const fibril_condvar_t*'.
-             *
-             *       The same applies to the wait_for and wait_until
-             *       functions.
-             */
-            virtual void wait()
-            {
-                aux::threading::mutex::lock(mutex_);
+            virtual void wait() const
+            {
+                aux::threading::mutex::lock(
+                    const_cast<aux::mutex_t&>(mutex_)
+                );
+
                 while (!value_set_)
-                    aux::threading::condvar::wait(condvar_, mutex_);
-                aux::threading::mutex::unlock(mutex_);
+                {
+                    aux::threading::condvar::wait(
+                        const_cast<aux::condvar_t&>(condvar_),
+                        const_cast<aux::mutex_t&>(mutex_)
+                    );
+                }
+
+                aux::threading::mutex::unlock(
+                    const_cast<aux::mutex_t&>(mutex_)
+                );
             }
 
             template<class Rep, class Period>
             future_status
-            wait_for(const chrono::duration<Rep, Period>& rel_time)
+            wait_for(const chrono::duration<Rep, Period>& rel_time) const
             {
                 if (value_set_)
                     return future_status::ready;
 
-                aux::threading::mutex::lock(mutex_);
+                aux::threading::mutex::lock(
+                    const_cast<aux::mutex_t&>(mutex_)
+                );
+
                 auto res = timed_wait_(
                     aux::threading::time::convert(rel_time)
                 );
-                aux::threading::mutex::unlock(mutex_);
+
+                aux::threading::mutex::unlock(
+                    const_cast<aux::mutex_t&>(mutex_)
+                );
 
                 return res;
@@ -134 +141 @@
                     return future_status::ready;
 
-                aux::threading::mutex::lock(mutex_);
+                aux::threading::mutex::lock(
+                    const_cast<aux::mutex_t&>(mutex_)
+                );
+
                 auto res = timed_wait_(
                     aux::threading::time::convert(abs_time - Clock::now())
                 );
-                aux::threading::mutex::unlock(mutex_);
+
+                aux::threading::mutex::unlock(
+                    const_cast<aux::mutex_t&>(mutex_)
+                );
 
                 return res;
@@ -164 +177 @@
              *       children).
              */
-            virtual future_status timed_wait_(aux::time_unit_t time)
+            virtual future_status timed_wait_(aux::time_unit_t time) const
             {
                 auto res = aux::threading::condvar::wait_for(
-                    condvar_, mutex_, time
+                    const_cast<aux::condvar_t&>(condvar_),
+                    const_cast<aux::mutex_t&>(mutex_), time
                 );
 
@@ -289 +303 @@
             }
 
-            void wait() override
+            void wait() const override
             {
                 if (!this->is_set())
-                    thread_.join();
+                    const_cast<thread&>(thread_).join();
             }
 
@@ -301 +315 @@
 
         protected:
-            future_status timed_wait_(aux::time_unit_t time) override
+            future_status timed_wait_(aux::time_unit_t time) const override
             {
                 /**
@@ -336 +350 @@
             }
 
-            void wait() override
+            void wait() const override
             {
                 /**
@@ -342 +356 @@
                  */
                 if (!this->is_set())
-                    invoke_(make_index_sequence<sizeof...(Args)>{});
+                {
+                    const_cast<
+                        deferred_shared_state<R, F, Args...>*
+                    >(this)->invoke_(make_index_sequence<sizeof...(Args)>{});
+                }
             }
 
@@ -373 +391 @@
             }
 
-            future_status timed_wait_(aux::time_unit_t) override
+            future_status timed_wait_(aux::time_unit_t) const override
             {
                 /**
@@ -398 +416 @@
     {
         // TODO: implement
+        __unimplemented();
     }
 
@@ -404 +423 @@
     {
         // TODO: implement
+        __unimplemented();
     }
 }

uspace/lib/cpp/src/__bits/runtime.cpp

@@ -28 +28 @@
 
 #include <__bits/abi.hpp>
+#include <cassert>
 #include <cstdlib>
 #include <cstdint>
@@ -211 +212 @@
     {
         // TODO: needed for thread_local variables
+        __unimplemented();
         return 0;
     }

uspace/lib/cpp/src/__bits/test/future.cpp

@@ -161 +161 @@
         std::thread t4{
             [&p4](){
-                p4.set_value_at_thread_exit(42);
+                /* p4.set_value_at_thread_exit(42); */
             }
         };
@@ -167 +167 @@
 
         /* test("shared state marked as ready at thread exit", s4->is_set()); */
-        test_eq("value set inside state while in thread", s4->get(), 42);
+        /* test_eq("value set inside state while in thread", s4->get(), 42); */
         /* test_eq("value set at thread exit", f4.get(), 42); */