From: wolf Date: Thu, 3 Feb 2000 17:35:18 +0000 (+0000) Subject: Add MemFunData for functions that do not take arguments. X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=6eca298e30df6a37cd99600aca0f44da11c87d06;p=dealii-svn.git Add MemFunData for functions that do not take arguments. git-svn-id: https://svn.dealii.org/trunk@2339 0785d39b-7218-0410-832d-ea1e28bc413d --- diff --git a/deal.II/base/include/base/thread_manager.h b/deal.II/base/include/base/thread_manager.h index 90006010da..cdc48b3689 100644 --- a/deal.II/base/include/base/thread_manager.h +++ b/deal.II/base/include/base/thread_manager.h @@ -306,6 +306,42 @@ class ThreadManager : public ACE_Thread_Manager { public: + /** + * This class is used to package + * all data needed to call a + * specific void member + * function of an object. See the + * general documentation of the + * #ThreadManager# class or of + * the class + * #ThreadManager::Mem_Fun_Data1# + * for more information. + */ + template + struct Mem_Fun_Data0 + { + typedef void * (Class::*MemFun) (); + + typedef void (Class::*VoidMemFun) (); + + Class *object; + MemFun mem_fun; + VoidMemFun void_mem_fun; + + Mem_Fun_Data0 (Class *object, + MemFun mem_fun) : + object (object), + mem_fun (mem_fun), + void_mem_fun (0) {}; + + Mem_Fun_Data0 (Class *object, + VoidMemFun void_mem_fun) : + object (object), + mem_fun (0), + void_mem_fun (void_mem_fun) {}; + }; + + /** * This class is used to package all * data needed to call a specific unary @@ -1293,6 +1329,24 @@ class ThreadManager : public ACE_Thread_Manager }; + /** + * Wrapper function to allow spawning + * threads for member functions as well, + * rather than for global functions only. + * + * This version is for member functions + * taking no arguments. + */ + template + int spawn (Mem_Fun_Data0 *mem_fun_data, + long flags = THR_NEW_LWP | THR_JOINABLE, + ACE_thread_t * = 0, + ACE_hthread_t *t_handle = 0, + long priority = ACE_DEFAULT_THREAD_PRIORITY, + int grp_id = -1, + void *stack = 0, + size_t stack_size = 0); + /** * Wrapper function to allow spawning * threads for member functions as well, @@ -1686,6 +1740,26 @@ class ThreadManager : public ACE_Thread_Manager void *stack = 0, size_t stack_size = 0); + /** + * Wrapper function to allow spawning + * multiple threads for member functions + * as well, rather than for global + * functions only. + * + * This version is for member functions + * taking a single argument. + */ + template + int spawn_n (size_t n, + Mem_Fun_Data0 *mem_fun_data, + long flags = THR_NEW_LWP | THR_JOINABLE, + long priority = ACE_DEFAULT_THREAD_PRIORITY, + int grp_id = -1, + ACE_Task_Base *task = 0, + ACE_hthread_t thread_handles[] = 0, + void *stack[] = 0, + size_t stack_size[] = 0); + /** * Wrapper function to allow spawning * multiple threads for member functions @@ -2138,6 +2212,16 @@ class ThreadManager : public ACE_Thread_Manager private: + /** + * This is a function satisfying the + * requirements for thread entry points. + * It takes as argument all the + * information necessary to call a + * void member function. + */ + template + static void * thread_entry_point0 (void *_arg); + /** * This is a function satisfying the * requirements for thread entry points. @@ -2384,6 +2468,29 @@ class ThreadManager : public ACE_Thread_Manager /* ------------------------------ Template functions -------------------------------- */ +template +int ThreadManager::spawn (Mem_Fun_Data0 *mem_fun_data, + long flags, + ACE_thread_t *t, + ACE_hthread_t *t_handle, + long priority, + int grp_id, + void *stack, + size_t stack_size) +{ + return ACE_Thread_Manager::spawn (&ThreadManager::template thread_entry_point0, + (void*)mem_fun_data, + flags, + t, + t_handle, + priority, + grp_id, + stack, + stack_size); +}; + + + template int ThreadManager::spawn (Mem_Fun_Data1 *mem_fun_data, long flags, @@ -2896,6 +3003,31 @@ int ThreadManager::spawn (Fun_Data10 +int ThreadManager::spawn_n (size_t n, + Mem_Fun_Data0 *mem_fun_data, + long flags, + long priority, + int grp_id, + ACE_Task_Base *task, + ACE_hthread_t thread_handles[], + void *stack[], + size_t stack_size[]) +{ + return ACE_Thread_Manager::spawn_n (n, + &ThreadManager::template thread_entry_point0, + (void*)mem_fun_data, + flags, + priority, + grp_id, + task, + thread_handles, + stack, + stack_size); +}; + + + template int ThreadManager::spawn_n (size_t n, Mem_Fun_Data1 *mem_fun_data, @@ -3434,6 +3566,29 @@ int ThreadManager::spawn_n (size_t n, }; +template +void * ThreadManager::thread_entry_point0 (void *_arg) +{ + // reinterpret the given pointer as + // a pointer to the structure + // containing all the necessary + // information + Mem_Fun_Data0 *arg = reinterpret_cast *>(_arg); + + // extract function pointer, object + // and argument and dispatch the + // call + if (arg->mem_fun != 0) + return (arg->object->*(arg->mem_fun))(); + else + { + (arg->object->*(arg->void_mem_fun))(); + return 0; + }; +}; + + + template void * ThreadManager::thread_entry_point1 (void *_arg) {