fix issue with unwrap shared state.

viboes · viboes · commit b7b2a463cfeb · 2015-05-03T22:32:17.000+02:00
diff --git a/include/boost/thread/future.hpp b/include/boost/thread/future.hpp
@@ -5042,41 +5042,70 @@ namespace detail
   template<typename F, typename Rp>
   struct future_unwrap_shared_state: shared_state<Rp>
   {
-    F parent;
+    F wrapped;
+    typename F::value_type unwrapped;
   public:
     explicit future_unwrap_shared_state(BOOST_THREAD_RV_REF(F) f)
-    : parent(boost::move(f)) {}
-
-    typename F::value_type parent_value(boost::unique_lock<boost::mutex>& ) {
-        typename F::value_type r = parent.get();
-        r.set_exceptional_if_invalid();
-        return boost::move(r);
+    : wrapped(boost::move(f)) {
     }
 
-    virtual void wait(boost::unique_lock<boost::mutex>& lk, bool ) { // todo see if rethrow must be used
-        parent_value(lk).wait();
+    void launch_continuation(boost::unique_lock<boost::mutex>& lk, shared_ptr<shared_state_base> that)
+    {
+      if (! unwrapped.valid() )
+      {
+        unwrapped = wrapped.get();
+        if (unwrapped.valid())
+        {
+          lk.unlock();
+          boost::unique_lock<boost::mutex> lk2(unwrapped.future_->mutex);
+          unwrapped.future_->set_continuation_ptr(this->shared_from_this(), lk2);
+        } else {
+          this->mark_exceptional_finish_internal(boost::copy_exception(future_uninitialized()), lk);
+        }
+      } else {
+        this->mark_finished_with_result_internal(unwrapped.get(), lk);
+      }
     }
-    virtual Rp get(boost::unique_lock<boost::mutex>& lk) {
-        return parent_value(lk).get();
+  };
+
+  template<typename F>
+  struct future_unwrap_shared_state<F,void>: shared_state<void>
+  {
+    F wrapped;
+    typename F::value_type unwrapped;
+  public:
+    explicit future_unwrap_shared_state(BOOST_THREAD_RV_REF(F) f)
+    : wrapped(boost::move(f)) {
     }
-#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
-    typedef shared_ptr<shared_state_base> continuation_ptr_type;
 
-    virtual void set_continuation_ptr(continuation_ptr_type continuation, boost::unique_lock<boost::mutex>& lock)
+    void launch_continuation(boost::unique_lock<boost::mutex>& lk, shared_ptr<shared_state_base> that)
     {
-      boost::unique_lock<boost::mutex> lk(parent.future_->mutex);
-      parent.future_->set_continuation_ptr(continuation, lk);
+      if (! unwrapped.valid() )
+      {
+        unwrapped = wrapped.get();
+        if (unwrapped.valid())
+        {
+          lk.unlock();
+          boost::unique_lock<boost::mutex> lk2(unwrapped.future_->mutex);
+          unwrapped.future_->set_continuation_ptr(this->shared_from_this(), lk2);
+        } else {
+          this->mark_exceptional_finish_internal(boost::copy_exception(future_uninitialized()), lk);
+        }
+      } else {
+        unwrapped.wait();
+        this->mark_finished_with_result_internal(lk);
+      }
     }
-#endif
   };
 
+
   template <class F, class Rp>
   BOOST_THREAD_FUTURE<Rp>
   make_future_unwrap_shared_state(boost::unique_lock<boost::mutex> &lock, BOOST_THREAD_RV_REF(F) f) {
     shared_ptr<future_unwrap_shared_state<F, Rp> >
         h(new future_unwrap_shared_state<F, Rp>(boost::move(f)));
     lock.lock();
-    h->parent.future_->set_continuation_ptr(h, lock);
+    h->wrapped.future_->set_continuation_ptr(h, lock);
     lock.unlock();
     return BOOST_THREAD_FUTURE<Rp>(h);
   }
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
@@ -957,9 +957,7 @@ rule thread-compile ( sources : reqs * : name )
     explicit ts_ ;
     test-suite ts_
     :
-          #[ thread-compile test_10963.cpp : : test_10963_c ]
-          #[ thread-run test_10964.cpp ]
-          [ thread-run test_11256.cpp ]
+          #[ thread-run test_11256.cpp ]
     ;
 
 
diff --git a/test/test_10964.cpp b/test/test_10964.cpp
@@ -48,6 +48,8 @@ void p1()
 
 int main()
 {
+  const int number_of_tests = 2;
+
 #if ! defined  BOOST_NO_CXX11_DECLTYPE && ! defined  BOOST_NO_CXX11_AUTO_DECLARATIONS
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
   {
@@ -56,24 +58,30 @@ int main()
     f1.wait();
   }
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+  for (int i=0; i< number_of_tests; i++)
   {
     auto f1 = boost::make_ready_future().then(TestCallback());
+    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
+    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     auto f2 = f1.unwrap();
+    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     BOOST_STATIC_ASSERT(std::is_same<decltype(f2), boost::future<void> >::value);
+    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     f2.wait();
+    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
   }
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+  for (int i=0; i< number_of_tests; i++)
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     auto f1 = boost::make_ready_future().then(TestCallback());
     BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
     boost::future<void> f2 = f1.get();
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
   }
-#if 0
-  // @fixme this doesn't works.
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+  for (int i=0; i< number_of_tests; i++)
   {
     auto f1 = boost::make_ready_future().then(TestCallback());
     BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
@@ -84,18 +92,20 @@ int main()
     f3.wait();
   }
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+  for (int i=0; i< number_of_tests; i++)
   {
         boost::make_ready_future().then(
             TestCallback()).unwrap().then(TestCallback()).get();
   }
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+  for (int i=0; i< number_of_tests; i++)
   {
     boost::future<void> f = boost::async(p1);
     f.then(
             TestCallback()).unwrap().then(TestCallback()).get();
   }
-#endif
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+  for (int i=0; i< number_of_tests; i++)
   {
     auto f1 = boost::make_ready_future().then(TestCallback());
     BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
@@ -106,6 +116,7 @@ int main()
 
 
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+  for (int i=0; i< number_of_tests; i++)
   {
     boost::basic_thread_pool executor;
     auto f1 = boost::make_ready_future().then(executor, TestCallback());
@@ -114,24 +125,24 @@ int main()
     BOOST_STATIC_ASSERT(std::is_same<decltype(f3), boost::future<boost::future<void> > >::value);
     f3.wait();
   }
-#if 0
-  // @fixme this doesn't works.
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+  for (int i=0; i< number_of_tests; i++)
   {
-    boost::basic_thread_pool executor;
+    boost::basic_thread_pool executor(1);
 
     auto f1 = boost::make_ready_future().then(executor, TestCallback());
     BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);
-    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+    std::cout << __FILE__ << "[" << __LINE__ << "] " << int(f1.valid()) << std::endl;
     auto f2 = f1.unwrap();
-    std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+    std::cout << __FILE__ << "[" << __LINE__ << "] " << int(f2.valid()) << std::endl;
 
     BOOST_STATIC_ASSERT(std::is_same<decltype(f2), boost::future<void> >::value);
     auto f3 = f2.then(executor, TestCallback());
     BOOST_STATIC_ASSERT(std::is_same<decltype(f3), boost::future<boost::future<void> > >::value);
     f3.wait();
   }
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
+  for (int i=0; i< number_of_tests; i++)
   {
     boost::basic_thread_pool executor;
 
@@ -143,7 +154,6 @@ int main()
     BOOST_STATIC_ASSERT(std::is_same<decltype(f3), boost::future<boost::future<void> > >::value);
     f3.wait();
   }
-#endif
   std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
 
 #endif

Original file line number	Diff line number	Diff line change
`@@ -957,9 +957,7 @@ rule thread-compile ( sources : reqs * : name )`
`957`	`957`	`explicit ts_ ;`
`958`	`958`	`test-suite ts_`
`959`	`959`	`:`
`960`		`- #[ thread-compile test_10963.cpp : : test_10963_c ]`
`961`		`- #[ thread-run test_10964.cpp ]`
`962`		`- [ thread-run test_11256.cpp ]`
	`960`	`+ #[ thread-run test_11256.cpp ]`
`963`	`961`	`;`
`964`	`962`
`965`	`963`
Original file line number	Diff line number	Diff line change
`@@ -48,6 +48,8 @@ void p1()`
`48`	`48`
`49`	`49`	`int main()`
`50`	`50`	`{`
	`51`	`+ const int number_of_tests = 2;`
	`52`	`+`
`51`	`53`	`#if ! defined BOOST_NO_CXX11_DECLTYPE && ! defined BOOST_NO_CXX11_AUTO_DECLARATIONS`
`52`	`54`	`std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
`53`	`55`	`{`
`@@ -56,24 +58,30 @@ int main()`
`56`	`58`	`f1.wait();`
`57`	`59`	`}`
`58`	`60`	`std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
	`61`	`+ for (int i=0; i< number_of_tests; i++)`
`59`	`62`	`{`
`60`	`63`	`auto f1 = boost::make_ready_future().then(TestCallback());`
	`64`	`+ std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
`61`	`65`	`BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);`
	`66`	`+ std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
`62`	`67`	`auto f2 = f1.unwrap();`
	`68`	`+ std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
`63`	`69`	`BOOST_STATIC_ASSERT(std::is_same<decltype(f2), boost::future<void> >::value);`
	`70`	`+ std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
`64`	`71`	`f2.wait();`
	`72`	`+ std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
`65`	`73`	`}`
`66`	`74`	`std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
	`75`	`+ for (int i=0; i< number_of_tests; i++)`
`67`	`76`	`{`
`68`	`77`	`std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
`69`	`78`	`auto f1 = boost::make_ready_future().then(TestCallback());`
`70`	`79`	`BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);`
`71`	`80`	`boost::future<void> f2 = f1.get();`
`72`	`81`	`std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
`73`	`82`	`}`
`74`		`-#if 0`
`75`		`- // @fixme this doesn't works.`
`76`	`83`	`std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
	`84`	`+ for (int i=0; i< number_of_tests; i++)`
`77`	`85`	`{`
`78`	`86`	`auto f1 = boost::make_ready_future().then(TestCallback());`
`79`	`87`	`BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);`
`@@ -84,18 +92,20 @@ int main()`
`84`	`92`	`f3.wait();`
`85`	`93`	`}`
`86`	`94`	`std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
	`95`	`+ for (int i=0; i< number_of_tests; i++)`
`87`	`96`	`{`
`88`	`97`	`boost::make_ready_future().then(`
`89`	`98`	`TestCallback()).unwrap().then(TestCallback()).get();`
`90`	`99`	`}`
`91`	`100`	`std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
	`101`	`+ for (int i=0; i< number_of_tests; i++)`
`92`	`102`	`{`
`93`	`103`	`boost::future<void> f = boost::async(p1);`
`94`	`104`	`f.then(`
`95`	`105`	`TestCallback()).unwrap().then(TestCallback()).get();`
`96`	`106`	`}`
`97`		`-#endif`
`98`	`107`	`std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
	`108`	`+ for (int i=0; i< number_of_tests; i++)`
`99`	`109`	`{`
`100`	`110`	`auto f1 = boost::make_ready_future().then(TestCallback());`
`101`	`111`	`BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);`
`@@ -106,6 +116,7 @@ int main()`
`106`	`116`
`107`	`117`
`108`	`118`	`std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
	`119`	`+ for (int i=0; i< number_of_tests; i++)`
`109`	`120`	`{`
`110`	`121`	`boost::basic_thread_pool executor;`
`111`	`122`	`auto f1 = boost::make_ready_future().then(executor, TestCallback());`
`@@ -114,24 +125,24 @@ int main()`
`114`	`125`	`BOOST_STATIC_ASSERT(std::is_same<decltype(f3), boost::future<boost::future<void> > >::value);`
`115`	`126`	`f3.wait();`
`116`	`127`	`}`
`117`		`-#if 0`
`118`		`- // @fixme this doesn't works.`
`119`	`128`	`std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
	`129`	`+ for (int i=0; i< number_of_tests; i++)`
`120`	`130`	`{`
`121`		`- boost::basic_thread_pool executor;`
	`131`	`+ boost::basic_thread_pool executor(1);`
`122`	`132`
`123`	`133`	`auto f1 = boost::make_ready_future().then(executor, TestCallback());`
`124`	`134`	`BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value);`
`125`		`- std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
	`135`	`+ std::cout << __FILE__ << "[" << __LINE__ << "] " << int(f1.valid()) << std::endl;`
`126`	`136`	`auto f2 = f1.unwrap();`
`127`		`- std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
	`137`	`+ std::cout << __FILE__ << "[" << __LINE__ << "] " << int(f2.valid()) << std::endl;`
`128`	`138`
`129`	`139`	`BOOST_STATIC_ASSERT(std::is_same<decltype(f2), boost::future<void> >::value);`
`130`	`140`	`auto f3 = f2.then(executor, TestCallback());`
`131`	`141`	`BOOST_STATIC_ASSERT(std::is_same<decltype(f3), boost::future<boost::future<void> > >::value);`
`132`	`142`	`f3.wait();`
`133`	`143`	`}`
`134`	`144`	`std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
	`145`	`+ for (int i=0; i< number_of_tests; i++)`
`135`	`146`	`{`
`136`	`147`	`boost::basic_thread_pool executor;`
`137`	`148`
`@@ -143,7 +154,6 @@ int main()`
`143`	`154`	`BOOST_STATIC_ASSERT(std::is_same<decltype(f3), boost::future<boost::future<void> > >::value);`
`144`	`155`	`f3.wait();`
`145`	`156`	`}`
`146`		`-#endif`
`147`	`157`	`std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;`
`148`	`158`
`149`	`159`	`#endif`