Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 46c66f8 in mainline


Ignore:
Timestamp:
2019-07-07T12:59:11Z (16 months ago)
Author:
Jaroslav Jindrak <dzejrou@…>
Branches:
master
Children:
8c0b781
Parents:
8e24583
Message:

cpp: apply requested changes

Location:
uspace/lib/cpp
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/cpp/include/__bits/thread/async.hpp

    r8e24583 r46c66f8  
    6969             * Note: The case when async | deferred is set in policy
    7070             *       is implementation defined, feel free to change.
     71             * Rationale: We chose the 'deferred' policy, because unlike
     72             *            the 'async' policy it carries no possible
     73             *            surprise ('async' can fail due to thread
     74             *            creation error).
    7175             */
    7276            if (async && deferred)
  • uspace/lib/cpp/include/__bits/thread/packaged_task.hpp

    r8e24583 r46c66f8  
    4545     */
    4646
     47    /**
     48     * Note: The base template is not defined because
     49     *       we require the template parameter to be
     50     *       a callable object (e.g. a function). This
     51     *       is achieved by the R(Args...) specialization
     52     *       below.
     53     */
    4754    template<class>
    48     class packaged_task; // undefined
     55    class packaged_task;
    4956
    5057    template<class R, class... Args>
  • uspace/lib/cpp/include/__bits/thread/shared_state.hpp

    r8e24583 r46c66f8  
    9393            }
    9494
    95             /**
    96              * TODO: This member function is supposed to be marked
    97              *       as 'const'. In such a case, however, we cannot
    98              *       use the underlying fibril API because these
    99              *       references get converted to pointers and the API
    100              *       does not accept e.g. 'const fibril_condvar_t*'.
    101              *
    102              *       The same applies to the wait_for and wait_until
    103              *       functions.
    104              */
    105             virtual void wait()
    106             {
    107                 aux::threading::mutex::lock(mutex_);
     95            virtual void wait() const
     96            {
     97                aux::threading::mutex::lock(
     98                    const_cast<aux::mutex_t&>(mutex_)
     99                );
     100
    108101                while (!value_set_)
    109                     aux::threading::condvar::wait(condvar_, mutex_);
    110                 aux::threading::mutex::unlock(mutex_);
     102                {
     103                    aux::threading::condvar::wait(
     104                        const_cast<aux::condvar_t&>(condvar_),
     105                        const_cast<aux::mutex_t&>(mutex_)
     106                    );
     107                }
     108
     109                aux::threading::mutex::unlock(
     110                    const_cast<aux::mutex_t&>(mutex_)
     111                );
    111112            }
    112113
    113114            template<class Rep, class Period>
    114115            future_status
    115             wait_for(const chrono::duration<Rep, Period>& rel_time)
     116            wait_for(const chrono::duration<Rep, Period>& rel_time) const
    116117            {
    117118                if (value_set_)
    118119                    return future_status::ready;
    119120
    120                 aux::threading::mutex::lock(mutex_);
     121                aux::threading::mutex::lock(
     122                    const_cast<aux::mutex_t&>(mutex_)
     123                );
     124
    121125                auto res = timed_wait_(
    122126                    aux::threading::time::convert(rel_time)
    123127                );
    124                 aux::threading::mutex::unlock(mutex_);
     128
     129                aux::threading::mutex::unlock(
     130                    const_cast<aux::mutex_t&>(mutex_)
     131                );
    125132
    126133                return res;
     
    134141                    return future_status::ready;
    135142
    136                 aux::threading::mutex::lock(mutex_);
     143                aux::threading::mutex::lock(
     144                    const_cast<aux::mutex_t&>(mutex_)
     145                );
     146
    137147                auto res = timed_wait_(
    138148                    aux::threading::time::convert(abs_time - Clock::now())
    139149                );
    140                 aux::threading::mutex::unlock(mutex_);
     150
     151                aux::threading::mutex::unlock(
     152                    const_cast<aux::mutex_t&>(mutex_)
     153                );
    141154
    142155                return res;
     
    164177             *       children).
    165178             */
    166             virtual future_status timed_wait_(aux::time_unit_t time)
     179            virtual future_status timed_wait_(aux::time_unit_t time) const
    167180            {
    168181                auto res = aux::threading::condvar::wait_for(
    169                     condvar_, mutex_, time
     182                    const_cast<aux::condvar_t&>(condvar_),
     183                    const_cast<aux::mutex_t&>(mutex_), time
    170184                );
    171185
     
    289303            }
    290304
    291             void wait() override
     305            void wait() const override
    292306            {
    293307                if (!this->is_set())
    294                     thread_.join();
     308                    const_cast<thread&>(thread_).join();
    295309            }
    296310
     
    301315
    302316        protected:
    303             future_status timed_wait_(aux::time_unit_t time) override
     317            future_status timed_wait_(aux::time_unit_t time) const override
    304318            {
    305319                /**
     
    336350            }
    337351
    338             void wait() override
     352            void wait() const override
    339353            {
    340354                /**
     
    342356                 */
    343357                if (!this->is_set())
    344                     invoke_(make_index_sequence<sizeof...(Args)>{});
     358                {
     359                    const_cast<
     360                        deferred_shared_state<R, F, Args...>*
     361                    >(this)->invoke_(make_index_sequence<sizeof...(Args)>{});
     362                }
    345363            }
    346364
     
    373391            }
    374392
    375             future_status timed_wait_(aux::time_unit_t) override
     393            future_status timed_wait_(aux::time_unit_t) const override
    376394            {
    377395                /**
     
    398416    {
    399417        // TODO: implement
     418        __unimplemented();
    400419    }
    401420
     
    404423    {
    405424        // TODO: implement
     425        __unimplemented();
    406426    }
    407427}
  • uspace/lib/cpp/src/__bits/runtime.cpp

    r8e24583 r46c66f8  
    2828
    2929#include <__bits/abi.hpp>
     30#include <cassert>
    3031#include <cstdlib>
    3132#include <cstdint>
     
    211212    {
    212213        // TODO: needed for thread_local variables
     214        __unimplemented();
    213215        return 0;
    214216    }
  • uspace/lib/cpp/src/__bits/test/future.cpp

    r8e24583 r46c66f8  
    161161        std::thread t4{
    162162            [&p4](){
    163                 p4.set_value_at_thread_exit(42);
     163                /* p4.set_value_at_thread_exit(42); */
    164164            }
    165165        };
     
    167167
    168168        /* test("shared state marked as ready at thread exit", s4->is_set()); */
    169         test_eq("value set inside state while in thread", s4->get(), 42);
     169        /* test_eq("value set inside state while in thread", s4->get(), 42); */
    170170        /* test_eq("value set at thread exit", f4.get(), 42); */
    171171
Note: See TracChangeset for help on using the changeset viewer.