Changeset 54715


Ignore:
Timestamp:
Jul 6, 2009, 5:11:38 PM (9 years ago)
Author:
olli
Message:
  • callable in manin namespace
  • new class context
  • user-defined execution-policies supported
Location:
sandbox/task
Files:
2 added
2 deleted
17 edited

Legend:

Unmodified
Added
Removed
  • sandbox/task/boost/task.hpp

    r54058 r54715  
    1111#include <boost/task/async.hpp>
    1212#include <boost/task/bounded_channel.hpp>
     13#include <boost/task/callable.hpp>
     14#include <boost/task/context.hpp>
    1315#include <boost/task/exceptions.hpp>
    1416#include <boost/task/fifo.hpp>
  • sandbox/task/boost/task/as_sub_task.hpp

    r54565 r54715  
    1313#include <boost/thread/detail/move.hpp>
    1414
    15 #include <boost/task/detail/interrupter.hpp>
     15#include <boost/task/context.hpp>
    1616#include <boost/task/detail/worker.hpp>
    1717#include <boost/task/future.hpp>
     
    2424namespace boost { namespace task
    2525{
     26
    2627struct as_sub_task
    2728{
     
    3233                if ( w)
    3334                {
    34                         shared_future< R > fut( t.get_future() );
    35                         detail::interrupter intr;
     35                        shared_future< R > f( t.get_future() );
    3636                        function< bool() > wcb(
    3737                                bind(
    3838                                        & shared_future< R >::is_ready,
    39                                         fut) );
     39                                        f) );
    4040                        t.set_wait_callback(
    4141                                bind(
     
    4343                                        w,
    4444                                        wcb) );
    45                         w->put( detail::callable( boost::move( t), intr) );
    46                         return handle< R >( fut, intr);
     45                        context ctx;
     46                        handle< R > h( ctx.get_handle( f) );
     47                        w->put( ctx.get_callable( boost::move( t) ) );
     48                        return h;
    4749                }
    4850                else
     
    5052        }
    5153};
    52 } }
     54
     55}}
    5356
    5457#include <boost/config/abi_suffix.hpp>
  • sandbox/task/boost/task/bounded_channel.hpp

    r54565 r54715  
    1919#include <boost/thread/shared_mutex.hpp>
    2020
    21 #include <boost/task/detail/callable.hpp>
     21#include <boost/task/callable.hpp>
    2222#include <boost/task/exceptions.hpp>
    2323#include <boost/task/watermark.hpp>
     
    9393        }
    9494
    95         const std::vector< detail::callable > drain_()
     95        const std::vector< callable > drain_()
    9696        {
    9797                BOOST_ASSERT( deactive_now_() );
    98                 std::vector< detail::callable > unprocessed;
     98                std::vector< callable > unprocessed;
    9999                unprocessed.reserve( queue_.size() );
    100                 BOOST_FOREACH( detail::callable ca, queue_)
     100                BOOST_FOREACH( callable ca, queue_)
    101101                { unprocessed.push_back( ca); }
    102102                clear_();
     
    136136                unique_lock< shared_mutex > & lk)
    137137        {
    138                 not_full_cond_.wait(
    139                         lk,
    140                         bind(
    141                                 & bounded_channel::producers_activate_,
    142                                 this) );
     138                if ( full_() )
     139                {
     140                        not_full_cond_.wait(
     141                                lk,
     142                                bind(
     143                                        & bounded_channel::producers_activate_,
     144                                        this) );
     145                }
    143146                if ( ! active_() )
    144147                        throw task_rejected("channel is not active");
     
    153156                unique_lock< shared_mutex > & lk)
    154157        {
    155                 if ( ! not_full_cond_.timed_wait(
    156                         lk,
    157                         rel_time,
    158                         bind(
    159                                 & bounded_channel::producers_activate_,
    160                                 this) ) )
    161                         throw task_rejected("timed out");
     158                if ( full_() )
     159                {
     160                        if ( ! not_full_cond_.timed_wait(
     161                                lk,
     162                                rel_time,
     163                                bind(
     164                                        & bounded_channel::producers_activate_,
     165                                        this) ) )
     166                                throw task_rejected("timed out");
     167                }
    162168                if ( ! active_() )
    163169                        throw task_rejected("channel is not active");
     
    167173
    168174        bool take_(
    169                 detail::callable & ca,
     175                callable & ca,
    170176                unique_lock< shared_mutex > & lk)
    171177        {
    172178                if ( deactive_now_() || ( deactive_() && empty_() ) )
    173179                        return false;
    174                 try
    175                 {
    176                         not_empty_cond_.wait(
    177                                 lk,
    178                                 bind(
    179                                         & bounded_channel::consumers_activate_,
    180                                         this) );
    181                 }
    182                 catch ( thread_interrupted const&)
    183                 { return false; }
     180                if ( empty_() )
     181                {
     182                        try
     183                        {
     184                                not_empty_cond_.wait(
     185                                        lk,
     186                                        bind(
     187                                                & bounded_channel::consumers_activate_,
     188                                                this) );
     189                        }
     190                        catch ( thread_interrupted const&)
     191                        { return false; }
     192                }
    184193                if ( deactive_now_() || ( deactive_() && empty_() ) )
    185194                        return false;
     
    199208        template< typename Duration >
    200209        bool take_(
    201                 detail::callable & ca,
     210                callable & ca,
    202211                Duration const& rel_time,
    203212                unique_lock< shared_mutex > & lk)
     
    205214                if ( deactive_now_() || ( deactive_() && empty_() ) )
    206215                        return false;
    207                 try
    208                 {
    209                         if ( ! not_empty_cond_.timed_wait(
    210                                 lk,
    211                                 rel_time,
    212                                 bind(
    213                                         & bounded_channel::consumers_activate_,
    214                                         this) ) )
    215                                 return false;
    216                 }
    217                 catch ( thread_interrupted const&)
    218                 { return false; }
     216                if ( empty_() )
     217                {
     218                        try
     219                        {
     220                                if ( ! not_empty_cond_.timed_wait(
     221                                        lk,
     222                                        rel_time,
     223                                        bind(
     224                                                & bounded_channel::consumers_activate_,
     225                                                this) ) )
     226                                        return false;
     227                        }
     228                        catch ( thread_interrupted const&)
     229                        { return false; }
     230                }
    219231                if ( deactive_now_() || ( deactive_() && empty_() ) )
    220232                        return false;
     
    232244        }
    233245
    234         bool try_take_( detail::callable & ca)
     246        bool try_take_( callable & ca)
    235247        {
    236248                if ( deactive_now_() || empty_() )
    237249                        return false;
    238250                ca = queue_.pop();
    239                 if ( size_() <= lwm_)
     251                bool valid = ! ca.empty();
     252                if ( valid && size_() <= lwm_)
    240253                {
    241254                        if ( lwm_ == hwm_)
     
    246259                                not_full_cond_.notify_all();
    247260                }
    248                 return ! ca.empty();
     261                return valid;
    249262        }
    250263
     
    305318        }
    306319
    307         const std::vector< detail::callable > drain()
     320        const std::vector< callable > drain()
    308321        {
    309322                lock_guard< shared_mutex > lk( mtx_);
     
    368381        }
    369382
    370         bool take( detail::callable & ca)
     383        bool take( callable & ca)
    371384        {
    372385                unique_lock< shared_mutex > lk( mtx_);
     
    376389        template< typename Duration >
    377390        bool take(
    378                 detail::callable & ca,
     391                callable & ca,
    379392                Duration const& rel_time)
    380393        {
     
    383396        }
    384397
    385         bool try_take( detail::callable & ca)
     398        bool try_take( callable & ca)
    386399        {
    387400                lock_guard< shared_mutex > lk( mtx_);
  • sandbox/task/boost/task/detail/interrupter.hpp

    r54465 r54715  
    3535        {
    3636        private:
    37                 bool                                    interruption_requested_;
     37                bool                                    requested_;
    3838                mutex                                   mtx_;
    3939                shared_ptr< thread >    thrd_;
    4040
    41                 void set_( shared_ptr< thread > const& thrd);
     41                void reset_();
    4242
    43                 void reset_();
     43                void reset_( shared_ptr< thread > const& thrd);
    4444
    4545                void interrupt_();
     
    4848                impl();
    4949
    50                 void set( shared_ptr< thread > const& thrd);
     50                void reset();
    5151
    52                 void reset();
     52                void reset( shared_ptr< thread > const& thrd);
    5353
    5454                void interrupt();
     
    6060
    6161public:
    62         class scoped_guard : public noncopyable
    63         {
    64         private:
    65                 interrupter     &       intr_;
    66        
    67         public:
    68                 scoped_guard( interrupter &, shared_ptr< thread > &);
    69        
    70                 ~scoped_guard();
    71         };
    72 
    7362        interrupter();
    7463
    75         void set( shared_ptr< thread > const& thrd);
     64        void reset();
    7665
    77         void reset();
     66        void reset( shared_ptr< thread > const& thrd);
    7867
    7968        void interrupt();
     
    8170        bool interruption_requested();
    8271
    83         void swap( interrupter & other)
    84         { impl_.swap( other.impl_); }
     72        void swap( interrupter & other);
    8573};
    8674}}}
  • sandbox/task/boost/task/detail/worker.hpp

    r54465 r54715  
    1818#include <boost/utility.hpp>
    1919
     20#include <boost/task/callable.hpp>
    2021#include <boost/task/detail/config.hpp>
    21 #include <boost/task/detail/callable.hpp>
    2222#include <boost/task/detail/guard.hpp>
    2323#include <boost/task/detail/interrupter.hpp>
     
    108108                        guard grd( get_pool().active_worker_);
    109109                        {
    110                                 interrupter::scoped_guard lk( ca.get_interrupter(), thrd_);
     110                                callable::context_guard lk( ca, thrd_);
    111111                                ca();
    112112                        }
  • sandbox/task/boost/task/detail/wsq.hpp

    r54401 r54715  
    1313#include <boost/utility.hpp>
    1414
     15#include <boost/task/callable.hpp>
    1516#include <boost/task/detail/config.hpp>
    16 #include <boost/task/detail/callable.hpp>
    1717
    1818#include <boost/config/abi_prefix.hpp>
     
    3030{
    3131private:
    32         const int                                               initial_size_;
     32        const int                                       initial_size_;
    3333        shared_array< callable >        array_;
    34         int                                                             capacity_;
    35         int                                                             mask_;
    36         volatile uint32_t                               head_idx_;
    37         volatile uint32_t                               tail_idx_;
    38         recursive_mutex                                 mtx_;
     34        int                                                     capacity_;
     35        int                                                     mask_;
     36        volatile uint32_t                       head_idx_;
     37        volatile uint32_t                       tail_idx_;
     38        recursive_mutex                         mtx_;
    3939
    4040public:
  • sandbox/task/boost/task/fifo.hpp

    r54401 r54715  
    1111#include <list>
    1212
    13 #include <boost/task/detail/callable.hpp>
     13#include <boost/task/callable.hpp>
    1414#include <boost/task/detail/meta.hpp>
    1515
     
    2525        {
    2626        public:
    27                 typedef detail::callable                                        item;
     27                typedef callable                                                        item;
    2828                typedef std::list< item >::iterator                     iterator;
    2929                typedef std::list< item >::const_iterator       const_iterator;
  • sandbox/task/boost/task/handle.hpp

    r54565 r54715  
    2020{
    2121
     22class context;
     23
    2224template< typename R >
    2325class handle
    2426{
    2527private:
     28        friend class context;
     29
    2630        shared_future< R >              fut_;
    2731        detail::interrupter             intr_;
    28 
    29 public:
    30         handle()
    31         : fut_(), intr_()
    32         {}
    33 
    34         handle( shared_future< R > fut)
    35         :
    36         fut_( fut),
    37         intr_()
    38         {}
    3932
    4033        handle(
     
    4639        {}
    4740
     41public:
     42        handle()
     43        : fut_(), intr_()
     44        {}
     45
    4846        void interrupt()
    4947        { intr_.interrupt(); }
     
    135133        {
    136134                fut_.swap( other.fut_);
    137                 intr_.swap( other.intr_);
     135//              intr_.swap( other.intr_);
    138136        }
    139137};
     
    236234        { throw task_interrupted(); }
    237235}
    238 
    239236}}
    240237
  • sandbox/task/boost/task/new_thread.hpp

    r54465 r54715  
    88#define BOOST_TASK_NEW_THREAD_H
    99
     10#include <boost/assert.hpp>
    1011#include <boost/config.hpp>
    1112#include <boost/shared_ptr.hpp>
     
    1314#include <boost/thread/detail/move.hpp>
    1415
    15 #include <boost/task/detail/interrupter.hpp>
    16 #include <boost/task/detail/callable.hpp>
     16#include <boost/task/context.hpp>
    1717#include <boost/task/future.hpp>
    1818#include <boost/task/handle.hpp>
     
    2525namespace detail
    2626{
    27 struct joiner
     27class joiner
    2828{
     29private:
     30        callable        ca_;
     31
     32public:
     33        joiner( callable const& ca)
     34        : ca_( ca)
     35        {}
     36
    2937        void operator()( thread * thrd)
    3038        {
    3139                try
    32                 { thrd->join(); }
     40                {
     41                        ca_.reset();
     42                        BOOST_ASSERT( thrd);
     43                        BOOST_ASSERT( thrd->joinable() );
     44                        thrd->join();
     45                }
    3346                catch (...)
    3447                {}
     
    3649        }
    3750};
    38 
    3951}
    4052
     
    4456        handle< R > operator()( task< R > t)
    4557        {
    46                 shared_future< R > fut( t.get_future() );
     58                shared_future< R > f( t.get_future() );
     59                context ctx;
     60                handle< R > h( ctx.get_handle( f) );
     61                callable ca( ctx.get_callable( boost::move( t) ) );
     62                shared_ptr< thread > thrd(
     63                        new thread( ca),
     64                        detail::joiner( ca) );
     65                ca.reset( thrd);
    4766
    48                 detail::interrupter intr;
    49                 shared_ptr< thread > thrd(
    50                         new thread(
    51                                 detail::callable(
    52                                         boost::move( t),
    53                                         intr) ),
    54                         detail::joiner() );
    55                 intr.set( thrd);
    56 
    57                 return handle< R >( fut, intr);
     67                return h;
    5868        }
    5969};
    60 } }
     70}}
    6171
    6272#include <boost/config/abi_suffix.hpp>
  • sandbox/task/boost/task/own_thread.hpp

    r54465 r54715  
    1111#include <boost/thread/detail/move.hpp>
    1212
    13 #include <boost/task/detail/interrupter.hpp>
     13#include <boost/task/callable.hpp>
     14#include <boost/task/context.hpp>
     15#include <boost/task/future.hpp>
    1416#include <boost/task/handle.hpp>
    1517#include <boost/task/task.hpp>
     
    2426        handle< R > operator()( task< R > t)
    2527        {
    26                 shared_future< R > fut( t.get_future() );
    27                 t();
    28                 return handle< R >( fut);
     28                shared_future< R > f( t.get_future() );
     29                context ctx;
     30                handle< R > h( ctx.get_handle( f) );
     31                callable ca( ctx.get_callable( boost::move( t) ) );
     32                ca();
     33                return h;
    2934        }
    3035};
    31 } }
     36}}
    3237
    3338#include <boost/config/abi_suffix.hpp>
  • sandbox/task/boost/task/priority.hpp

    r54401 r54715  
    1616#include <boost/multi_index/ordered_index.hpp>
    1717
    18 #include <boost/task/detail/callable.hpp>
     18#include <boost/task/callable.hpp>
    1919#include <boost/task/detail/meta.hpp>
    2020
     
    4242                {
    4343                private:
    44                         detail::callable        ca_;
    45                         attribute                       attr_;
     44                        callable        ca_;
     45                        attribute       attr_;
    4646       
    4747                public:
    4848                        item(
    49                                 detail::callable const& ca,
     49                                callable const& ca,
    5050                                attribute const& attr)
    5151                        : ca_( ca), attr_( attr)
    5252                        { BOOST_ASSERT( ! ca_.empty() ); }
    5353       
    54                         const detail::callable ca() const
     54                        const callable ca() const
    5555                        { return ca_; }
    5656       
     
    9191                { idx_.insert( itm); }
    9292       
    93                 const detail::callable pop()
     93                const callable pop()
    9494                {
    9595                        iterator i( lst_.begin() );
  • sandbox/task/boost/task/smart.hpp

    r54401 r54715  
    1515#include <boost/multi_index/ordered_index.hpp>
    1616
    17 #include <boost/task/detail/callable.hpp>
     17#include <boost/task/callable.hpp>
    1818#include <boost/task/detail/meta.hpp>
    1919
     
    4545                {
    4646                private:
    47                         detail::callable        ca_;
    48                         attribute                       attr_;
     47                        callable        ca_;
     48                        attribute       attr_;
    4949       
    5050                public:
     
    5454
    5555                        item(
    56                                 detail::callable const& ca,
     56                                callable const& ca,
    5757                                attribute const& attr)
    5858                        : ca_( ca), attr_( attr)
    5959                        { BOOST_ASSERT( ! ca_.empty() ); }
    6060       
    61                         const detail::callable ca() const
     61                        const callable ca() const
    6262                        { return ca_; }
    6363       
     
    104104                { enq_op_( idx_, itm); }
    105105       
    106                 const detail::callable pop()
     106                const callable pop()
    107107                {
    108108                        item itm;
  • sandbox/task/boost/task/static_pool.hpp

    r54565 r54715  
    2121#include <boost/thread/detail/move.hpp>
    2222
     23#include <boost/task/callable.hpp>
     24#include <boost/task/context.hpp>
    2325#include <boost/task/detail/atomic.hpp>
    2426#include <boost/task/detail/bind_processor.hpp>
    25 #include <boost/task/detail/interrupter.hpp>
    26 #include <boost/task/detail/callable.hpp>
    2727#include <boost/task/detail/worker.hpp>
    2828#include <boost/task/detail/worker_group.hpp>
     
    7474                friend class detail::worker::impl_pool;
    7575# endif
    76        
    77                 detail::worker_group            wg_;
     76
     77                detail::worker_group    wg_;
    7878                shared_mutex                    mtx_wg_;
    7979                volatile uint32_t               state_;
    80                 channel                         channel_;
     80                channel                                 channel_;
    8181                volatile uint32_t               active_worker_;
    8282                volatile uint32_t               idle_worker_;
     
    9292                        w.run();
    9393                }
    94                
     94
    9595                void create_worker_(
    9696                        poolsize const& psize,
     
    323323                                throw task_rejected("pool is closed");
    324324
    325                         shared_future< R > fut( t.get_future() );
    326                         detail::interrupter intr;
    327                         channel_.put( detail::callable( boost::move( t), intr) );
    328                         return handle< R >( fut, intr);
    329                 }
    330 
    331                 template<
    332                         typename R,
    333                         typename Attr
    334                 >
     325                        shared_future< R > f( t.get_future() );
     326                        context ctx;
     327                        handle< R > h( ctx.get_handle( f) );
     328                        channel_.put(
     329                                        ctx.get_callable( boost::move( t) ) );
     330                        return h;
     331                }
     332
     333                template< typename R, typename Attr >
    335334                handle< R > submit( task< R > t, Attr const& attr)
    336335                {
     
    338337                                throw task_rejected("pool is closed");
    339338
    340                         shared_future< R > fut( t.get_future() );
    341                         detail::interrupter intr;
    342                         channel_.put( channel_item( detail::callable( boost::move( t), intr), attr) );
    343                         return handle< R >( fut, intr);
     339                        shared_future< R > f( t.get_future() );
     340                        context ctx;
     341                        handle< R > h( ctx.get_handle( f) );
     342                        channel_.put(
     343                                        channel_item(
     344                                                ctx.get_callable( boost::move( t) ),
     345                                                attr) );
     346                        return h;
    344347                }
    345348        };
     
    534537        }
    535538
    536         template<
    537                 typename R,
    538                 typename Attr
    539         >
     539        template< typename R, typename Attr >
    540540        handle< R > submit( task< R > t, Attr const& attr)
    541541        {
  • sandbox/task/boost/task/task.hpp

    r54565 r54715  
    1515#include <boost/utility/result_of.hpp>
    1616
     17#include <boost/task/exceptions.hpp>
    1718#include <boost/task/future.hpp>
    18 #include <boost/task/exceptions.hpp>
    1919
    2020#include <boost/config/abi_prefix.hpp>
     
    2222namespace boost { namespace task
    2323{
    24 template< typename Channel >
    25 class static_pool;
    26 
    27 struct as_sub_task;
    28 
    2924namespace detail
    3025{
     
    178173{
    179174private:
    180         template< typename Channel >
    181         friend class static_pool;
    182 
    183         friend struct as_sub_task;
    184 
    185175        struct dummy;
    186176
     
    279269# undef BOOST_TASK_CTOR
    280270
    281         unique_future< R > get_future()
    282         {
    283                 if ( ! task_)
    284                         throw task_moved();
    285                 return task_->get_future();
    286         }
    287 
    288271        void operator()()
    289272        {
     
    291274                        throw task_moved();
    292275                task_->run();
     276        }
     277
     278        unique_future< R > get_future()
     279        {
     280                if ( ! task_)
     281                        throw task_moved();
     282                return task_->get_future();     
    293283        }
    294284
     
    348338{ return task::task< R >( t); }
    349339# endif
    350 
    351340}
    352341
  • sandbox/task/boost/task/unbounded_channel.hpp

    r54565 r54715  
    1919#include <boost/thread/shared_mutex.hpp>
    2020
    21 #include <boost/task/detail/callable.hpp>
     21#include <boost/task/callable.hpp>
    2222#include <boost/task/exceptions.hpp>
    2323
     
    8989        }
    9090
    91         const std::vector< detail::callable > drain_()
     91        const std::vector< callable > drain_()
    9292        {
    9393                BOOST_ASSERT( deactive_now_() );
    94                 std::vector< detail::callable > unprocessed;
     94                std::vector< callable > unprocessed;
    9595                unprocessed.reserve( queue_.size() );
    96                 BOOST_FOREACH( detail::callable ca, queue_)
     96                BOOST_FOREACH( callable ca, queue_)
    9797                { unprocessed.push_back( ca); }
    9898                clear_();
     
    107107        { return queue_.size(); }
    108108
    109         void put_(
    110                 item const& itm,
    111                 unique_lock< shared_mutex > & lk)
     109        void put_( item const& itm)
    112110        {
    113111                if ( ! active_() )
     
    118116
    119117        bool take_(
    120                 detail::callable & ca,
     118                callable & ca,
    121119                unique_lock< shared_mutex > & lk)
    122120        {
    123121                if ( deactive_now_() || ( deactive_() && empty_() ) )
    124122                        return false;
    125                 try
    126                 {
    127                         not_empty_cond_.wait(
    128                                 lk,
    129                                 bind(
    130                                         & unbounded_channel::consumers_activate_,
    131                                         this) );
    132                 }
    133                 catch ( thread_interrupted const&)
    134                 { return false; }
     123                if ( empty_() )
     124                {
     125                        try
     126                        {
     127                                not_empty_cond_.wait(
     128                                        lk,
     129                                        bind(
     130                                                & unbounded_channel::consumers_activate_,
     131                                                this) );
     132                        }
     133                        catch ( thread_interrupted const&)
     134                        { return false; }
     135                }
    135136                if ( deactive_now_() || ( deactive_() && empty_() ) )
    136137                        return false;
     
    141142        template< typename Duration >
    142143        bool take_(
    143                 detail::callable & ca,
     144                callable & ca,
    144145                Duration const& rel_time,
    145146                unique_lock< shared_mutex > & lk)
     
    147148                if ( deactive_now_() || ( deactive_() && empty_() ) )
    148149                        return false;
    149                 try
    150                 {
    151                         if ( ! not_empty_cond_.timed_wait(
    152                                 lk,
    153                                 rel_time,
    154                                 bind(
    155                                         & unbounded_channel::consumers_activate_,
    156                                         this) ) )
    157                                 return false;
    158                 }
    159                 catch ( thread_interrupted const&)
    160                 { return false; }
     150                if ( empty_() )
     151                {
     152                        try
     153                        {
     154                                if ( ! not_empty_cond_.timed_wait(
     155                                        lk,
     156                                        rel_time,
     157                                        bind(
     158                                                & unbounded_channel::consumers_activate_,
     159                                                this) ) )
     160                                        return false;
     161                        }
     162                        catch ( thread_interrupted const&)
     163                        { return false; }
     164                }
    161165                if ( deactive_now_() || ( deactive_() && empty_() ) )
    162166                        return false;
     
    165169        }
    166170
    167         bool try_take_( detail::callable & ca)
     171        bool try_take_( callable & ca)
    168172        {
    169173                if ( deactive_now_() || empty_() )
     
    218222        }
    219223
    220         const std::vector< detail::callable > drain()
     224        const std::vector< callable > drain()
    221225        {
    222226                lock_guard< shared_mutex > lk( mtx_);
     
    241245        void put( item const& itm)
    242246        {
    243                 unique_lock< shared_mutex > lk( mtx_);
    244                 put_( itm, lk);
    245         }
    246 
    247         template< typename Duration >
    248         void put(
    249                 item & itm,
    250                 Duration const&)
    251         {
    252                 unique_lock< shared_mutex > lk( mtx_);
    253                 put_( itm, lk);
    254         }
    255 
    256         bool take( detail::callable & ca)
     247                lock_guard< shared_mutex > lk( mtx_);
     248                put_( itm);
     249        }
     250
     251        bool take( callable & ca)
    257252        {
    258253                unique_lock< shared_mutex > lk( mtx_);
     
    262257        template< typename Duration >
    263258        bool take(
    264                 detail::callable & ca,
     259                callable & ca,
    265260                Duration const& rel_time)
    266261        {
     
    269264        }
    270265
    271         bool try_take( detail::callable & ca)
     266        bool try_take( callable & ca)
    272267        {
    273268                lock_guard< shared_mutex > lk( mtx_);
  • sandbox/task/libs/task/src/callable.cpp

    r54465 r54715  
    55//          http://www.boost.org/LICENSE_1_0.txt)
    66
    7 #include "boost/task/detail/callable.hpp"
     7#include "boost/task/callable.hpp"
    88
    99namespace boost { namespace task
    1010{
    11 namespace detail
    12 {
     11
    1312callable::callable()
    1413: impl_()
     
    2726{ impl_.reset(); }
    2827
    29 interrupter &
    30 callable::get_interrupter()
    31 { return impl_->get_interrupter(); }
    32 } } }
     28void
     29callable::reset()
     30{ impl_->reset(); }
    3331
     32void
     33callable::reset( shared_ptr< thread > const& thrd)
     34{ impl_->reset( thrd); }
     35
     36}}
  • sandbox/task/libs/task/src/interrupter.cpp

    r54565 r54715  
    1313namespace detail
    1414{
     15
    1516void
    16 interrupter::impl::set_( shared_ptr< thread > const& thrd)
     17interrupter::impl::reset_( shared_ptr< thread > const& thrd)
    1718{
    1819        thrd_ = thrd;
    1920        BOOST_ASSERT( thrd_);
    20         if ( interruption_requested_)
     21        if ( requested_)
    2122                if ( thrd_) thrd_->interrupt();
    2223}
     
    2526interrupter::impl::reset_()
    2627{
     28        thrd_.reset();
    2729        try
    2830        { this_thread::interruption_point(); }
    2931        catch ( thread_interrupted const&)
    3032        {}
    31         thrd_.reset();
    3233        BOOST_ASSERT( ! this_thread::interruption_requested() );
    3334}
     
    3637interrupter::impl::interrupt_()
    3738{
    38         if ( ! interruption_requested_)
     39        if ( ! requested_)
    3940        {
    40                 interruption_requested_ = true;
     41                requested_ = true;
    4142                if ( thrd_) thrd_->interrupt();
    4243        }
     
    4546interrupter::impl::impl()
    4647:
    47 interruption_requested_( false),
     48requested_( false),
    4849mtx_(),
    4950thrd_()
     
    5152
    5253void
    53 interrupter::impl::set( shared_ptr< thread > const& thrd)
     54interrupter::impl::reset( shared_ptr< thread > const& thrd)
    5455{
    5556        lock_guard< mutex > lk( mtx_);
    56         set_( thrd);
     57        reset_( thrd);
    5758}
    5859
     
    7576{
    7677        lock_guard< mutex > lk( mtx_);
    77         return interruption_requested_;
     78        return requested_;
    7879}
    7980
     
    8384
    8485void
    85 interrupter::set( shared_ptr< thread > const& thrd)
    86 { impl_->set( thrd); }
     86interrupter::reset( shared_ptr< thread > const& thrd)
     87{ impl_->reset( thrd); }
    8788
    8889void
     
    9899{ return impl_->interruption_requested(); }
    99100
    100 interrupter::scoped_guard::scoped_guard( interrupter & intr, shared_ptr< thread > & thrd)
    101 : intr_( intr)
    102 { intr_.set( thrd); }
     101void
     102interrupter::swap( interrupter & other)
     103{ impl_.swap( other.impl_); }
    103104
    104 interrupter::scoped_guard::~scoped_guard()
    105 { intr_.reset(); }
    106 }
    107 } }
    108 
     105}}}
Note: See TracChangeset for help on using the changeset viewer.