[Boost-commit] svn:boost r49837 - sandbox/interthreads/libs/interthreads/test

Subject: [Boost-commit] svn:boost r49837 - sandbox/interthreads/libs/interthreads/test
From: vicente.botet_at_[hidden]
Date: 2008-11-19 06:05:13

Author: viboes
Date: 2008-11-19 06:05:12 EST (Wed, 19 Nov 2008)
New Revision: 49837
URL: http://svn.boost.org/trac/boost/changeset/49837

Log:
intterthreads version 0.1
Added:
   sandbox/interthreads/libs/interthreads/test/Jamfile.v2   (contents, props changed)
   sandbox/interthreads/libs/interthreads/test/test_thread_decorator.cpp   (contents, props changed)
   sandbox/interthreads/libs/interthreads/test/test_thread_shared_ptr.cpp   (contents, props changed)

Added: sandbox/interthreads/libs/interthreads/test/Jamfile.v2
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/test/Jamfile.v2	2008-11-19 06:05:12 EST (Wed, 19 Nov 2008)
@@ -0,0 +1,57 @@
+#  (C) Copyright William E. Kempf 2001. 
+#  (C) Copyright 2007 Anthony Williams. 
+#  (C) Copyright 2007 Vicente Botet Escriba. 
+#  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+#  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#
+# Boost.InterThreads test Jamfile
+#
+# Additional configuration variables used:
+#   1. PTW32 may be used on Win32 platforms to specify that the pthreads-win32
+#      library should be used instead of "native" threads. This feature is
+#      mostly used for testing and it's generally recommended you use the
+#      native threading libraries instead. PTW32 should be set to be a list
+#      of two strings, the first specifying the installation path of the
+#      pthreads-win32 library and the second specifying which library
+#      variant to link against (see the pthreads-win32 documentation).
+#      Example: jam -sPTW32="c:\pthreads-win32 pthreadVCE.lib"
+
+# bring in rules for testing
+import testing ;
+
+project
+    : requirements <library>/boost/test//boost_unit_test_framework/<link>static
+            <library>/boost/thread//boost_thread/<link>static
+      <include>../../..
+      <threading>multi
+      <target-os>cygwin
+      <threadapi>pthread
+      <variant>debug
+
+    ;
+
+rule interthreads-run ( sources )
+{
+    return 
+    [ run $(sources) ../build//boost_interthreads ]
+#    [ run $(sources) ../build//boost_interthreads/<link>static 
+#        : : : : $(sources[1]:B)_lib ]
+    ;
+}    
+
+{
+    test-suite "tests"
+        : 
+          [ interthreads-run test_thread_decorator.cpp ]
+          [ interthreads-run test_thread_shared_ptr.cpp ]
+    ;
+    test-suite "example"
+        : 
+          [ interthreads-run ../example/hello_world.cpp ]
+          [ interthreads-run ../example/mono_thread_id.cpp ]
+          [ interthreads-run ../example/basic_keep_alive.cpp ]
+          [ interthreads-run ../example/multiple_algorithms.cpp ]
+          
+          
+    ;
+}

Added: sandbox/interthreads/libs/interthreads/test/test_thread_decorator.cpp
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/test/test_thread_decorator.cpp	2008-11-19 06:05:12 EST (Wed, 19 Nov 2008)
@@ -0,0 +1,124 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Roland Schwarz 2006. 
+// (C) Copyright Vicente J. Botet Escriba 2008. 
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/interthreads for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <iostream>
+#include <boost/thread/tss.hpp>
+#include <boost/thread.hpp>
+#include <boost/interthreads/thread_decorator.hpp>
+//#include <boost/interthreads/thread_tuple.hpp>
+
+boost::mutex out_global_mutex;
+
+void cleanup_i(boost::thread::id* data) {
+	boost::mutex::scoped_lock out_guard(out_global_mutex);
+	std::cout << "cleanup_i " << *data <<" " << boost::this_thread::get_id()<<std::endl;
+}
+
+boost::thread_specific_ptr<boost::thread::id> specific_ptr_i(cleanup_i);
+
+boost::once_flag global_init_flag=BOOST_ONCE_INIT;
+void global_init() {
+	boost::mutex::scoped_lock out_guard(out_global_mutex);
+	std::cout << "global_init" << boost::this_thread::get_id()<<std::endl;
+}
+
+void thread_init_1() {
+	specific_ptr_i.reset(new boost::thread::id(boost::this_thread::get_id()));
+	boost::call_once(global_init_flag, global_init);
+	boost::mutex::scoped_lock out_guard(out_global_mutex);
+	std::cout << "thread_init_1 " << boost::this_thread::get_id()<<std::endl;
+}
+
+void thread_init_2() {
+	boost::mutex::scoped_lock out_guard(out_global_mutex);
+	std::cout << "thread_init_2 " << boost::this_thread::get_id()<<std::endl;
+}
+void sleep(int sec)
+{
+	boost::xtime t;
+	boost::xtime_get(&t,1);	
+    t.sec += sec; 
+    boost::thread::sleep(t);
+}
+
+void run1() {
+	sleep(3);
+	{
+		boost::mutex::scoped_lock out_guard(out_global_mutex);
+		std::cout << "long operation on" << boost::this_thread::get_id()<<std::endl;
+	}
+	sleep(10);
+	{
+		boost::mutex::scoped_lock out_guard(out_global_mutex);
+	    std::cout << "long operation end" << boost::this_thread::get_id()<<std::endl;
+    }
+}
+
+void run2() {
+	sleep(1);
+	{
+		boost::mutex::scoped_lock out_guard(out_global_mutex);
+		std::cout << "long operation on" << boost::this_thread::get_id()<<std::endl;
+	}
+	sleep(20);
+	{
+		boost::mutex::scoped_lock out_guard(out_global_mutex);
+	    std::cout << "long operation end" << boost::this_thread::get_id()<<std::endl;
+    }
+}
+
+boost::interthreads::thread_decoration p1(thread_init_1);
+boost::interthreads::thread_decoration p2(thread_init_2);
+
+
+int main(int argc, char* argv[])
+{
+    boost::interthreads::decorate();
+	
+	//boost::interthreads::thread_tuple<2> gr(boost::interthreads::make_decorator(run1), boost::interthreads::make_decorator(run2)); 
+    boost::interthreads::thread_decorator run1p(run1);
+    boost::interthreads::thread_decorator run2p(run2);
+	boost::thread pt1(run1p);
+	boost::thread pt2(run2p);
+//	boost::thread pt1(boost::interthreads::make_decorator(run1));
+//	boost::thread pt2(boost::interthreads::make_decorator(run2));
+	sleep(1);
+	boost::thread pt12(run1p);
+//	boost::thread pt12(boost::interthreads::make_decorator(run1));
+	sleep(1);
+	{
+		boost::mutex::scoped_lock out_guard(out_global_mutex);
+	    std::cout << "waiting pt1" <<std::endl;
+    }
+    
+	pt1.join();
+	{
+		boost::mutex::scoped_lock out_guard(out_global_mutex);
+	    std::cout << "waiting pt12" <<std::endl;
+    }
+	pt12.join();
+	//gr.join_all();
+	{
+		boost::mutex::scoped_lock out_guard(out_global_mutex);
+	    std::cout << "waiting pt2" <<std::endl;
+    }
+	pt2.join();
+	
+	{
+		boost::mutex::scoped_lock out_guard(out_global_mutex);
+	    std::cout << "END" <<std::endl;
+    }
+
+	return 0;
+}
+
+
+

Added: sandbox/interthreads/libs/interthreads/test/test_thread_shared_ptr.cpp
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/test/test_thread_shared_ptr.cpp	2008-11-19 06:05:12 EST (Wed, 19 Nov 2008)
@@ -0,0 +1,159 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Roland Schwarz 2006. 
+// (C) Copyright Vicente J. Botet Escriba 2008. 
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/interthreads for documentation.
+//
+// Based on the shared.cpp example from the threadalert library of Roland Schwarz 
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/thread/mutex.hpp>
+boost::mutex out_global_mutex;
+#include <boost/thread/locks.hpp>
+#include <boost/thread.hpp>
+#include <iostream>
+#include <boost/interthreads/thread_specific_shared_ptr.hpp>
+#include <boost/interthreads/thread_decorator.hpp>
+
+void sleep(int sec)
+{
+	boost::xtime t;
+	boost::xtime_get(&t,1);	t.sec += sec; boost::thread::sleep(t);
+}
+
+// A state class living in shared memory.
+// The class must have its own sync mechanism.
+class state {
+public:
+	state() : result(0)
+	{}
+	void set_result(int n)
+	{
+		boost::mutex::scoped_lock lock(monitor);
+		result = n;
+	}
+	int get_result()
+	{
+		boost::mutex::scoped_lock lock(monitor);
+		return result;
+	}
+    static void deleter(state * p) { delete p; }
+private:
+    ~state() {}    
+	boost::mutex monitor;
+	int result;
+};
+
+// The conventional tss pointer.
+// It can be seen as a memory space that is
+// only privately accessible by the thread,
+// when interpreted in our context.
+boost::thread_specific_ptr<int> private_int;
+
+// The thread member pointer.
+// Its syntax is almost the same when used
+// from "inside" a thread as that of the
+// thread_specific_ptr. I named it public
+// to underpin the fact it is accessible
+// from "outside" too. (Perhaps other names
+// than thread_specific_shared_ptr and thread_specific_ptr
+// would be more appropriate? Any suggestions?
+// E.g. thread_public_ptr and thread_private_ptr?)
+boost::interthreads::thread_specific_shared_ptr<state> public_state;
+
+// It might be convenient to have a function
+// that is called automatically on thread start
+// up to auto initialize the variables.
+void init_state_fn()
+{
+    {
+	    boost::mutex::scoped_lock out_guard(out_global_mutex);
+	    std::cout << "init_state_fn" << " " << boost::this_thread::get_id()<<std::endl;
+    }
+
+	public_state.reset(new state(), state::deleter);
+	private_int.reset(new int(0));
+}
+
+boost::interthreads::thread_decoration init_state(init_state_fn);
+
+
+void run()
+{
+    init_state_fn();
+	sleep(2);
+    {
+	    boost::mutex::scoped_lock out_guard(out_global_mutex);
+	    std::cout << "run " << " " << boost::this_thread::get_id()<<std::endl;
+    }
+	public_state->set_result(42);
+    
+	boost::shared_ptr<state> ths = public_state[boost::this_thread::get_id()];
+    int result;
+	result = ths->get_result();
+    {
+	    boost::mutex::scoped_lock out_guard(out_global_mutex);
+	    std::cout << "ahead " << result << " " << boost::this_thread::get_id()<<std::endl;
+    }
+	sleep(2);
+    
+}
+
+int main(int argc, char* argv[])
+{
+    int result;
+
+	boost::thread* th = new boost::thread(boost::interthreads::make_decorator(run));
+
+    const boost::shared_ptr<state> ths = public_state.wait_and_get(th->get_id());
+    if (ths.get()!=0) {
+	    result = ths->get_result();
+        {
+    	    boost::mutex::scoped_lock out_guard(out_global_mutex);
+	        std::cout << "ahead " << result << " " << boost::this_thread::get_id()<<std::endl;
+        }
+    }
+
+	private_int.reset(new int(0));
+	ths->set_result(1111);
+    if (ths.get()!=0) {
+	    result = ths->get_result();
+        {
+    	    boost::mutex::scoped_lock out_guard(out_global_mutex);
+	        std::cout << "ahead " << result << " " << boost::this_thread::get_id()<<std::endl;
+        }
+    }
+    
+    sleep(2);
+	boost::shared_ptr<state> ths3 = public_state[th->get_id()];
+    if (ths.get()!=0) {
+	    result = ths->get_result();
+        {
+    	    boost::mutex::scoped_lock out_guard(out_global_mutex);
+	        std::cout << "ahead " << result << " " << boost::this_thread::get_id()<<std::endl;
+        }
+    }
+
+	th->join();
+
+	delete th;
+
+	// We still may access the state object by means of the shared_ptr.
+    if (ths.get()!=0) {
+    	result = ths->get_result();
+        {
+	        boost::mutex::scoped_lock out_guard(out_global_mutex);
+	        std::cout << "ahead " << result << " " << boost::this_thread::get_id()<<std::endl;
+        }
+    }
+    const boost::shared_ptr<state> cths(new state(), state::deleter);
+    cths->set_result(2);
+    {
+        boost::mutex::scoped_lock out_guard(out_global_mutex);
+        std::cout << "xxx" << cths->get_result() << " " << boost::this_thread::get_id()<<std::endl;
+    }
+	return 0;
+}
+