Subject: [Boost-commit] svn:boost r50593 - sandbox/interthreads/libs/interthreads/example
From: vicente.botet_at_[hidden]
Date: 2009-01-14 12:58:42
Author: viboes
Date: 2009-01-14 12:58:41 EST (Wed, 14 Jan 2009)
New Revision: 50593
URL: http://svn.boost.org/trac/boost/changeset/50593
Log:
interthreads version 0.2
Adding threader/joiner
Adding Asynchronous Executors fmk
Text files modified:
sandbox/interthreads/libs/interthreads/example/basic_keep_alive.cpp | 105 +++++++++++-----------
sandbox/interthreads/libs/interthreads/example/hello_world.cpp | 134 +++++-----------------------
sandbox/interthreads/libs/interthreads/example/mono_thread_id.cpp | 182 +++++++++++++++++++++++++--------------
sandbox/interthreads/libs/interthreads/example/multiple_algorithms.cpp | 110 ++++++++++++-----------
4 files changed, 253 insertions(+), 278 deletions(-)
Modified: sandbox/interthreads/libs/interthreads/example/basic_keep_alive.cpp
==============================================================================
--- sandbox/interthreads/libs/interthreads/example/basic_keep_alive.cpp (original)
+++ sandbox/interthreads/libs/interthreads/example/basic_keep_alive.cpp 2009-01-14 12:58:41 EST (Wed, 14 Jan 2009)
@@ -26,66 +26,65 @@
// #include <boost/interthreads/threader.hpp>
// #include <boost/interthreads/joiner_tuple.hpp>
- #include <boost/interthreads/thread_decorator.hpp>
- #include <boost/interthreads/thread_keep_alive.hpp>
-// #include "./async_ostream.cpp"
- #include "./async_ostream.hpp"
- #include <boost/thread/thread.hpp>
- #include <iostream>
- #include <sstream>
+#include <boost/interthreads/thread_decorator.hpp>
+#include <boost/interthreads/thread_keep_alive.hpp>
+
+#include <boost/interthreads/typeof/threader_decorator.hpp>
+#include <boost/interthreads/wait_for_all.hpp>
+//#include <boost/type_traits.hpp>
+
+#include "./async_ostream.hpp"
+#include <boost/thread/thread.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <sstream>
- namespace bith = boost::interthreads;
+namespace bith = boost::interthreads;
- int my_thread1() {
- sleep(2);
- return 1;
- }
- void my_thread() {
- bith::this_thread::enable_keep_alive enabler;
- for (int i=0; i<10; i++) {
- bith::this_thread::keep_alive_point();
+int my_thread1() {
+ sleep(2);
+ return 0;
+}
+int my_thread() {
+ bith::this_thread::enable_keep_alive enabler;
+ for (int i=0; i<10; i++) {
+ bith::this_thread::keep_alive_point();
- boost::thread::id id= boost::this_thread::get_id();
- std::stringstream sss;
+ boost::thread::id id= boost::this_thread::get_id();
+ std::stringstream sss;
#define COUT_
#ifdef COUT_
- bith::cout_ << "TID=" << i << " " << id << std::endl;
- bith::cout_.flush();
+ bith::cout_ << "TID=" << i << " " << id << std::endl;
+ bith::cout_.flush();
#else
- {
- boost::lock_guard<boost::mutex> lock(out_global_mutex2);
- std::cout << "TID=" << i << " " << id << std::endl;
- }
-#endif
- boost::this_thread::sleep(boost::posix_time::milliseconds(10));
+ {
+ boost::lock_guard<boost::mutex> lock(out_global_mutex2);
+ std::cout << "TID=" << i << " " << id << std::endl;
}
+#endif
+ boost::this_thread::sleep(boost::posix_time::milliseconds(10));
}
+ return 0;
+}
- int main() {
- #if 0
- bith::threader MyThreader;
- {
- bith::joiner<void> MyJoiner(MyThreader.fork(my_thread));
- MyJoiner.join();
- std::cout << "end" << std::endl;
- }
- {
- bith::joiner<int> MyJoiner(MyThreader.fork(my_thread1));
- int i = MyJoiner.get();
- std::cout << "i=" << i << std::endl;
- }
- #endif
- boost::thread th1(bith::make_decorator(my_thread));
- boost::thread th2(bith::make_decorator(my_thread));
- boost::thread th3(bith::make_decorator(my_thread));
- boost::thread th4(bith::make_decorator(my_thread));
- boost::thread th5(bith::make_decorator(my_thread));
-
- th1.join();
- th2.join();
- th3.join();
- th4.join();
- th5.join();
- sleep(2);
- return 0;
+int main() {
+ {
+ bith::shared_threader_decorator ae;
+ bith::wait_for_all(ae, my_thread, my_thread);
}
+ #if 0
+ boost::thread th1(bith::make_decorator(my_thread));
+ boost::thread th2(bith::make_decorator(my_thread));
+ boost::thread th3(bith::make_decorator(my_thread));
+ boost::thread th4(bith::make_decorator(my_thread));
+ boost::thread th5(bith::make_decorator(my_thread));
+ th1.join();
+ th2.join();
+ th3.join();
+ th4.join();
+ th5.join();
+ #endif
+
+
+ return 0;
+}
Modified: sandbox/interthreads/libs/interthreads/example/hello_world.cpp
==============================================================================
--- sandbox/interthreads/libs/interthreads/example/hello_world.cpp (original)
+++ sandbox/interthreads/libs/interthreads/example/hello_world.cpp 2009-01-14 12:58:41 EST (Wed, 14 Jan 2009)
@@ -11,118 +11,34 @@
//////////////////////////////////////////////////////////////////////////////
#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
+#include <boost/interthreads/typeof/threader_decorator.hpp>
+
boost::mutex out_global_mutex;
- #include <iostream>
- #include <boost/interthreads/thread_decorator.hpp>
- #include <boost/thread.hpp>
- #include <boost/function.hpp>
+#include <iostream>
+#include <boost/interthreads/thread_decorator.hpp>
+#include <boost/thread.hpp>
+#include <boost/function.hpp>
- namespace bith = boost::interthreads;
+namespace bith = boost::interthreads;
- void my_setup() {
- std::cout << "Hello World!" << std::endl;
- }
-
- void my_cleanup() {
- std::cout << "Bye, Bye!" << std::endl;
- }
-
- bith::thread_decoration my_decoration(my_setup, my_cleanup);
-
- struct mycallable1
- {
- void operator()() const {
- std::cout << "mycallable1" << std::endl;
- };
- };
-
- struct mycallable2
- {
- void operator()() const {
- std::cout << "mycallable2" << std::endl;
- };
- };
- void my_thread() {
- std::cout << "..." << std::endl;
-// mycallable1 x;
-// boost::this_thread::at_thread_exit(x);
- }
-
- template <typename F>
- void my_test(F f) {
- F cpy = f;
- cpy();
- }
-
- struct X {
- template <typename F>
- X(F f) {
- F cpy = f;
- cpy();
- }
- };
-
- int main() {
-#if 0
- mycallable2 x;
- boost::this_thread::at_thread_exit(x);
-// boost::thread th1(x);
-
- bith::thread_decorator my_thread_d1(my_thread);
- my_test(my_thread_d1);
- X x1(my_thread_d1);
-
- bith::thread_decorator my_thread_d2(my_thread_d1);
- my_test(my_thread_d1);
- X x2(my_thread_d2);
-
- bith::thread_decorator my_thread_d3;
- my_thread_d3 = my_thread_d2;
- my_test(my_thread_d2);
- X x3(my_thread_d3);
-#endif
-#if 1
- bith::thread_decorator my_thread_d(my_thread);
-// boost::thread th(my_thread_d);
-
-// boost::detail::thread_move_t<bith::thread_decorator> mt(my_thread_d);
-// boost::thread th(mt);
- boost::thread th(bith::make_decorator(my_thread));
- boost::thread th2(bith::make_decorator(my_thread));
-
-// boost::function<void ()> fct(my_thread_d);
-// fct();
-// boost::thread th(boost::ref(my_thread_d));
-// boost::thread th(boost::detail::thread_move_t<bith::thread_decorator>(my_thread_d));
-// boost::thread th(boost::move(my_thread_d));
-// boost::thread th(fct);
-
- {
- boost::mutex::scoped_lock out_guard(out_global_mutex);
- std::cout << "waiting1 " <<std::endl;
- }
- th.join();
- {
- boost::mutex::scoped_lock out_guard(out_global_mutex);
- std::cout << "waiting2" <<std::endl;
- }
- th2.join();
- {
- boost::mutex::scoped_lock out_guard(out_global_mutex);
- std::cout << "end" <<std::endl;
- }
-#endif
-
-#if 0
- mycallable2 c2;
- boost::function<void ()> fct(c2);
- boost::thread th2(fct);
- th2.join();
-#endif
+void my_setup() {
+ std::cout << "Hello World!" << std::endl;
+}
+
+void my_cleanup() {
+ std::cout << "Bye, Bye!" << std::endl;
+}
-// boost::thread th(my_thread_d);
-// boost::thread th(my_thread);
+bith::thread_decoration my_decoration(my_setup, my_cleanup);
- return 0;
- }
+void my_thread() {
+ std::cout << "..." << std::endl;
+}
+
+
+int main() {
+ boost::thread th(bith::make_decorator(my_thread));
+ th.join();
+ return 0;
+}
Modified: sandbox/interthreads/libs/interthreads/example/mono_thread_id.cpp
==============================================================================
--- sandbox/interthreads/libs/interthreads/example/mono_thread_id.cpp (original)
+++ sandbox/interthreads/libs/interthreads/example/mono_thread_id.cpp 2009-01-14 12:58:41 EST (Wed, 14 Jan 2009)
@@ -22,89 +22,141 @@
boost::thread::sleep(t);
}
- #include <boost/interthreads/thread_decorator.hpp>
- #include <boost/interthreads/thread_specific_shared_ptr.hpp>
- #include <boost/thread/thread.hpp>
- #include <iostream>
+#include <boost/fusion/include/for_each.hpp>
+
+#include <boost/interthreads/thread_decorator.hpp>
+#include <boost/interthreads/thread_specific_shared_ptr.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/interthreads/fork_all.hpp>
+#include <boost/interthreads/algorithm.hpp>
+#include <boost/interthreads/typeof/threader_decorator.hpp>
+
+#include <iostream>
- namespace bith = boost::interthreads;
+namespace bith = boost::interthreads;
- struct mono_thread_id {
- static bith::thread_decoration decoration_;
- typedef bith::thread_specific_shared_ptr<unsigned> tssp_type;
- static tssp_type current_;
- static unsigned counter_;
- static boost::mutex sync_;
+struct mono_thread_id {
+ static bith::thread_decoration decoration_;
+ typedef bith::thread_specific_shared_ptr<unsigned> tssp_type;
+ static tssp_type current_;
+ static unsigned counter_;
+ static boost::mutex sync_;
- static unsigned create() {
- boost::lock_guard<boost::mutex> lock(sync_);
- unsigned res = counter_;
- ++counter_;
- return res;
- }
- static void setup() {
- std::cout << "setup" << std::endl;
- current_.reset(new unsigned(create()));
- }
- public:
- static unsigned id() {
- return *current_;
- }
- static unsigned id(boost::thread::id id) {
+ static unsigned create() {
+ boost::lock_guard<boost::mutex> lock(sync_);
+ unsigned res = counter_;
+ ++counter_;
+ return res;
+ }
+ static void setup() {
+ std::cout << "setup" << std::endl;
+ current_.reset(new unsigned(create()));
+ }
+public:
+ static unsigned id() {
+ return *current_;
+ }
+ static unsigned id(boost::thread::id id) {
- boost::shared_ptr<unsigned> shp = current_[id];
- if (shp.get()!=0) {
- return *shp;
- } else {
- return 0xffffffff;
- }
+ boost::shared_ptr<unsigned> shp = current_[id];
+ if (shp.get()!=0) {
+ return *shp;
+ } else {
+ return 0xffffffff;
}
+ }
- };
+};
- bith::thread_decoration mono_thread_id::decoration_(mono_thread_id::setup);
- mono_thread_id::tssp_type mono_thread_id::current_;
- unsigned mono_thread_id::counter_=0;
- boost::mutex mono_thread_id::sync_;
-
- void my_thread() {
- {
- boost::lock_guard<boost::mutex> lock(out_global_mutex);
- std::cout << ">> thread::id=" << boost::this_thread::get_id() << " mono_thread_id=" << mono_thread_id::id() << std::endl;
- }
- sleep(5);
- {
+struct mono_thread_id_out {
+ template<typename T>
+ void operator()(T& t) const {
+ std::cout << "thread::id=" << t.get_id()
+ << " mono_thread_id=" << mono_thread_id::id(t.get_id())
+ << std::endl;
+ }
+};
+
+struct mono_thread_id_wait_and_get {
+ template<typename T>
+ void operator()(T& t) const {
+ const boost::shared_ptr<unsigned> shp1 = mono_thread_id::current_.wait_and_get(t.get_id());
+ if (shp1.get()==0) {
boost::lock_guard<boost::mutex> lock(out_global_mutex);
- std::cout << "<< thread::id=" << boost::this_thread::get_id() << " mono_thread_id=" << mono_thread_id::id() << std::endl;
+ std::cout << "ERROR 1" << std::endl;
}
}
+};
+
+bith::thread_decoration mono_thread_id::decoration_(mono_thread_id::setup);
+mono_thread_id::tssp_type mono_thread_id::current_;
+unsigned mono_thread_id::counter_=0;
+boost::mutex mono_thread_id::sync_;
- int main() {
- boost::thread th1(bith::make_decorator(my_thread));
- boost::thread th2(bith::make_decorator(my_thread));
-
- const boost::shared_ptr<unsigned> shp1 = mono_thread_id::current_.wait_and_get(th1.get_id());
+void my_thread() {
+ {
+ boost::lock_guard<boost::mutex> lock(out_global_mutex);
+ std::cout << ">> thread::id=" << boost::this_thread::get_id() << " mono_thread_id=" << mono_thread_id::id() << std::endl;
+ }
+ sleep(5);
+ {
+ boost::lock_guard<boost::mutex> lock(out_global_mutex);
+ std::cout << "<< thread::id=" << boost::this_thread::get_id() << " mono_thread_id=" << mono_thread_id::id() << std::endl;
+ }
+}
+
+void doit() {
+ bith::shared_threader_decorator ae;
+ bith::result_of::fork_all<bith::shared_threader_decorator, boost::fusion::tuple<void(*)(), void(*)()> >::type handles =
+ bith::fork_all(ae, my_thread, my_thread);
+ {
+ const boost::shared_ptr<unsigned> shp1 = mono_thread_id::current_.wait_and_get(boost::fusion::at_c<0>(handles).get_id());
if (shp1.get()==0) {
boost::lock_guard<boost::mutex> lock(out_global_mutex);
std::cout << "ERROR 1" << std::endl;
}
-
- const boost::shared_ptr<unsigned> shp2 = mono_thread_id::current_.wait_and_get(th2.get_id());
- if (shp2.get()==0) {
+ }
+ {
+ const boost::shared_ptr<unsigned> shp1 = mono_thread_id::current_.wait_and_get(boost::fusion::at_c<1>(handles).get_id());
+ if (shp1.get()==0) {
boost::lock_guard<boost::mutex> lock(out_global_mutex);
- std::cout << "ERROR 2" << std::endl;
+ std::cout << "ERROR 1" << std::endl;
}
+ }
+ //sleep(1);
+ boost::fusion::for_each(handles, mono_thread_id_wait_and_get());
+ boost::fusion::for_each(handles, mono_thread_id_out());
+ bith::join_all(handles);
+}
- {
- unsigned u = mono_thread_id::id(th1.get_id());
- boost::lock_guard<boost::mutex> lock(out_global_mutex);
- std::cout << "thread::id=" << th1.get_id() << " mono_thread_id="
- << u << std::endl;
- }
+void doit_clasic() {
+ boost::thread th1(bith::make_decorator(my_thread));
+ boost::thread th2(bith::make_decorator(my_thread));
- th1.join();
- th2.join();
-
- return 0;
+ const boost::shared_ptr<unsigned> shp1 = mono_thread_id::current_.wait_and_get(th1.get_id());
+ if (shp1.get()==0) {
+ boost::lock_guard<boost::mutex> lock(out_global_mutex);
+ std::cout << "ERROR 1" << std::endl;
+ }
+
+ const boost::shared_ptr<unsigned> shp2 = mono_thread_id::current_.wait_and_get(th2.get_id());
+ if (shp2.get()==0) {
+ boost::lock_guard<boost::mutex> lock(out_global_mutex);
+ std::cout << "ERROR 2" << std::endl;
}
+
+ {
+ unsigned u = mono_thread_id::id(th1.get_id());
+ boost::lock_guard<boost::mutex> lock(out_global_mutex);
+ std::cout << "thread::id=" << th1.get_id() << " mono_thread_id="
+ << u << std::endl;
+ }
+
+ th1.join();
+ th2.join();
+}
+int main() {
+ doit();
+ return 0;
+}
Modified: sandbox/interthreads/libs/interthreads/example/multiple_algorithms.cpp
==============================================================================
--- sandbox/interthreads/libs/interthreads/example/multiple_algorithms.cpp (original)
+++ sandbox/interthreads/libs/interthreads/example/multiple_algorithms.cpp 2009-01-14 12:58:41 EST (Wed, 14 Jan 2009)
@@ -23,72 +23,80 @@
}
-// #include <boost/interthreads/thread_decorator.hpp>
- #include <boost/interthreads/thread_tuple.hpp>
- #include <boost/interthreads/thread_tuple_once.hpp>
- #include <boost/interthreads/thread_group_once.hpp>
- #include <boost/interthreads/thread_and_join.hpp>
- #include <boost/thread.hpp>
- #include <iostream>
+#include <boost/interthreads/thread_tuple.hpp>
+#include <boost/interthreads/thread_tuple_once.hpp>
+#include <boost/interthreads/thread_group_once.hpp>
+#include <boost/interthreads/thread_and_join.hpp>
+#include <boost/interthreads/typeof/threader.hpp>
+#include <boost/interthreads/wait_for_any.hpp>
+#include <boost/thread.hpp>
+#include <iostream>
- namespace bith = boost::interthreads;
+namespace bith = boost::interthreads;
- void my_thread1() {
- {
- boost::lock_guard<boost::mutex> lock(out_global_mutex);
- std::cout << "1 thread_id=" << boost::this_thread::get_id() << std::endl;
- }
- sleep(10);
+int my_thread1() {
+ {
+ boost::lock_guard<boost::mutex> lock(out_global_mutex);
+ std::cout << "1 thread_id=" << boost::this_thread::get_id() << std::endl;
}
+ sleep(3);
+ return 0;
+}
- void my_thread2() {
- {
- boost::lock_guard<boost::mutex> lock(out_global_mutex);
- std::cout << "2 thread_id=" << boost::this_thread::get_id() << std::endl;
- }
- sleep(5);
+int my_thread2() {
+ {
+ boost::lock_guard<boost::mutex> lock(out_global_mutex);
+ std::cout << "2 thread_id=" << boost::this_thread::get_id() << std::endl;
}
+ sleep(1);
+ return 0;
+}
- void my_thread3() {
- {
- boost::lock_guard<boost::mutex> lock(out_global_mutex);
- std::cout << "3 thread_id=" << boost::this_thread::get_id() << std::endl;
- }
- sleep(7);
+int my_thread3() {
+ {
+ boost::lock_guard<boost::mutex> lock(out_global_mutex);
+ std::cout << "3 thread_id=" << boost::this_thread::get_id() << std::endl;
}
+ sleep(2);
+ return 0;
+}
- int main() {
- bith::thread_tuple<3> tt_0(my_thread1, my_thread2, my_thread3);
- bith::thread_tuple<3> tt_1;
- tt_1= tt_0.move();
- bith::thread_tuple<3> tt_2(tt_1.move());
- bith::thread_tuple<3> tt(boost::move(tt_2));
+int main() {
+ bith::shared_threader ae;
+ BOOST_AUTO(handles,bith::fork_all(ae, my_thread1, my_thread2, my_thread3));
+ BOOST_AUTO(result,bith::wait_for_any(ae, my_thread1, my_thread2, my_thread3));
+ std::cout << "Algotithm " << result.first+1 << " finished the first with wait_for_any" << std::endl;
+
+ bith::thread_tuple<3> tt_0(my_thread1, my_thread2, my_thread3);
+ bith::thread_tuple<3> tt_1;
+ tt_1= tt_0.move();
+ bith::thread_tuple<3> tt_2(tt_1.move());
+ bith::thread_tuple<3> tt(boost::move(tt_2));
- tt.join_all();
- std::cout << "All finished join_all" << std::endl;
+ tt.join_all();
+ std::cout << "All finished join_all" << std::endl;
- bith::thread_tuple<3> kk_0= bith::make_thread_tuple(my_thread1, my_thread2, my_thread3);
- kk_0.join_all();
- std::cout << "All finished join_all" << std::endl;
+ bith::thread_tuple<3> kk_0= bith::make_thread_tuple(my_thread1, my_thread2, my_thread3);
+ kk_0.join_all();
+ std::cout << "All finished join_all" << std::endl;
-#if 0
+#if 0
- bith::thread_group_once tgo;
- boost::thread* th1 = tgo.create_thread(my_thread1);
- boost::thread* th2 = tgo.create_thread(my_thread2);
- boost::thread* th3 = tgo.create_thread(my_thread3);
- boost::thread* res_tgo= tgo.join_any();
- std::cout << "Algotithm " << res_tgo << " " << th2 << " finished the first with thread_group_once::join_any" << std::endl;
+ bith::thread_group_once tgo;
+ boost::thread* th1 = tgo.create_thread(my_thread1);
+ boost::thread* th2 = tgo.create_thread(my_thread2);
+ boost::thread* th3 = tgo.create_thread(my_thread3);
+ boost::thread* res_tgo= tgo.join_any();
+ std::cout << "Algotithm " << res_tgo << " " << th2 << " finished the first with thread_group_once::join_any" << std::endl;
- bith::conc_join_all(my_thread1, my_thread2, my_thread3);
- std::cout << "All finished conc_join_all" << std::endl;
+ bith::conc_join_all(my_thread1, my_thread2, my_thread3);
+ std::cout << "All finished conc_join_all" << std::endl;
- unsigned res = bith::conc_join_any(my_thread1, my_thread2, my_thread3);
- std::cout << "Algotithm " << res+1 << " finished the first with conc_join_any" << std::endl;
+ unsigned res = bith::conc_join_any(my_thread1, my_thread2, my_thread3);
+ std::cout << "Algotithm " << res+1 << " finished the first with conc_join_any" << std::endl;
#endif
- return 0;
- }
-
+ return 0;
+}