MADNESS  version 0.9
taskfn.h
Go to the documentation of this file.
1 /*
2  This file is part of MADNESS.
3 
4  Copyright (C) 2007,2010 Oak Ridge National Laboratory
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 2 of the License, or
9  (at your option) any later version.
10 
11  This program is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  GNU General Public License for more details.
15 
16  You should have received a copy of the GNU General Public License
17  along with this program; if not, write to the Free Software
18  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 
20  For more information please contact:
21 
22  Robert J. Harrison
23  Oak Ridge National Laboratory
24  One Bethel Valley Road
25  P.O. Box 2008, MS-6367
26 
27  email: harrisonrj@ornl.gov
28  tel: 865-241-3937
29  fax: 865-572-0680
30 
31 
32  $Id $
33  */
34 
35 #ifndef MADNESS_WORLD_TASKFN_H__INCLUDED
36 #define MADNESS_WORLD_TASKFN_H__INCLUDED
37 
38 #include <madness/world/worlddep.h>
39 #include <madness/world/worldthread.h>
40 #include <madness/world/worldfut.h>
41 
42 namespace madness {
43 
44 
45  // Forward decls
46  class World;
47  class WorldTaskQueue;
48 
49  namespace detail {
50  template <typename, typename, typename> class MemFuncWrapper;
51  template <typename ptrT, typename memfnT, typename resT>
52  memfnT get_mem_func_ptr(const MemFuncWrapper<ptrT, memfnT, resT>&);
53  }
54 
56 
68  class TaskInterface : public PoolTaskInterface, public DependencyInterface {
69  friend class WorldTaskQueue;
70  private:
71  volatile World* world;
72  CallbackInterface* completion;
73 
74  // Used for submission to underlying queue when all dependencies are satisfied
75  struct Submit : public CallbackInterface {
76  PoolTaskInterface* p;
77  Submit(PoolTaskInterface* p) : p(p) {}
78  void notify() {
79  ThreadPool::add(p);
80  }
81  } submit;
82 
83 
85 
88  void set_info(World* w, CallbackInterface* c) {
89  world = w;
90  completion = c;
91  }
92 
94  void register_submit_callback() { register_callback(&submit); }
95 
96  protected:
97  virtual void run(const TaskThreadEnv& env);
98 
99  public:
100  static bool debug;
101 
103  TaskInterface(int ndepend=0, const TaskAttributes attr = TaskAttributes())
104  : PoolTaskInterface(attr)
105  , DependencyInterface(ndepend)
106  , world(0)
107  , completion(0)
108  , submit(this)
109  {}
110 
112  explicit TaskInterface(const TaskAttributes& attr)
113  : PoolTaskInterface(attr)
114  , DependencyInterface(0)
115  , world(0)
116  , completion(0)
117  , submit(this)
118  {}
119 
120 // void serialize(Buffer& ar) {
121 // throw "there is no way this is correct";
122 // ar & *static_cast<PoolTaskInterface*>(this) & world;
123 // }
124 
126 
128  virtual void run(World&) {
129  //print("in virtual run(world) method");
130  MADNESS_EXCEPTION("World TaskInterface: user did not implement one of run(world) or run(world, taskthreadenv)", 0);
131  }
132 
134  virtual void run(World& world, const TaskThreadEnv& env) {
135  //print("in virtual run(world,env) method", env.nthread(), env.id());
136  if (env.nthread() != 1)
137  MADNESS_EXCEPTION("World TaskInterface: user did not implement run(world, taskthreadenv) for multithreaded task", 0);
138  run(world);
139  }
140 
141  World* get_world() const { return const_cast<World*>(world); }
142 
143  virtual ~TaskInterface() { if (completion) completion->notify(); }
144 
145  }; // class TaskInterface
146 
147  namespace detail {
148 
149  template <typename T>
150  struct ArgCountHelper {
151  static const unsigned int value = 1u;
152  };
153 
154  template <>
155  struct ArgCountHelper<void> {
156  static const unsigned int value = 0u;
157  };
158 
159  // Counts the number of arguments that will be given to a task function
160  template <typename a1T, typename a2T, typename a3T, typename a4T, typename a5T,
161  typename a6T, typename a7T, typename a8T, typename a9T>
162  struct ArgCount : public std::integral_constant<unsigned int, ArgCountHelper<a1T>::value
163  + ArgCountHelper<a2T>::value + ArgCountHelper<a3T>::value
164  + ArgCountHelper<a4T>::value + ArgCountHelper<a5T>::value
165  + ArgCountHelper<a6T>::value + ArgCountHelper<a7T>::value
166  + ArgCountHelper<a8T>::value + ArgCountHelper<a9T>::value> {
167  };
168 
169 
171  template <typename Arg>
172  class ArgHolder : private NO_DEFAULTS{
173  private:
174  Arg arg_;
175  public:
176 
177  ArgHolder(const Arg& arg) : arg_(arg) { }
178 
179  ArgHolder(const archive::BufferInputArchive& input_arch) :
180  arg_()
181  {
182  input_arch & arg_;
183  }
184 
185  operator Arg&() { return arg_; }
186  }; // class ArgHolder
187 
188 
189  template <typename T>
190  struct task_arg {
191  typedef T type;
192  typedef ArgHolder<T> holderT;
193  };
194 
195  template <typename T>
196  struct task_arg<Future<T> > {
197  typedef T type;
198  typedef Future<T> holderT;
199  };
200 
201  template <>
202  struct task_arg<Future<void> > {
203  typedef const Future<void> type;
204  typedef const Future<void> holderT;
205  };
206 
207  template <>
208  struct task_arg<void> {
209  typedef const Future<void> type;
210  typedef const Future<void> holderT;
211  };
212 
213  template <typename fnT>
214  struct task_result_type {
215  typedef typename madness::remove_fcvr<typename madness::detail::result_of<fnT>::type>::type resultT;
216  typedef Future<resultT> futureT;
217  typedef futureT type;
218  };
219 
222  typedef Future<void> voidT;
223 
224 
225  // These functions are used to differentiate the task function calls
226  // based on the number of arguments and return type.
227 
228  // Note: voidT arguments must be const or the wrong function will be
229  // selected.
230 
231  template <typename fnT>
232  inline typename enable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
233  run_function(Future<void>& result, fnT fn, const voidT&,
234  const voidT&, const voidT&, const voidT&, const voidT&,
235  const voidT&, const voidT&, const voidT&, const voidT&)
236  { fn(); result.set(); }
237 
238  template <typename fnT, typename a1T>
239  inline typename enable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
240  run_function(Future<void>& result, fnT fn, a1T& a1,
241  const voidT&, const voidT&, const voidT&, const voidT&,
242  const voidT&, const voidT&, const voidT&, const voidT&)
243  { fn(a1); result.set(); }
244 
245  template <typename fnT, typename a1T, typename a2T>
246  inline typename enable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
247  run_function(Future<void>& result, fnT fn, a1T& a1, a2T& a2,
248  const voidT&, const voidT&, const voidT&, const voidT&,
249  const voidT&, const voidT&, const voidT&)
250  { fn(a1, a2); result.set(); }
251 
252  template <typename fnT, typename a1T, typename a2T, typename a3T>
253  inline typename enable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
254  run_function(Future<void>& result, fnT fn, a1T& a1, a2T& a2,
255  a3T& a3, const voidT&, const voidT&, const voidT&, const voidT&,
256  const voidT&, const voidT&)
257  { fn(a1, a2, a3); result.set(); }
258 
259  template <typename fnT, typename a1T, typename a2T, typename a3T, typename a4T>
260  inline typename enable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
261  run_function(Future<void>& result, fnT fn, a1T& a1, a2T& a2,
262  a3T& a3, a4T& a4, const voidT&, const voidT&, const voidT&,
263  const voidT&, const voidT&)
264  { fn(a1, a2, a3, a4); result.set(); }
265 
266  template <typename fnT, typename a1T, typename a2T, typename a3T, typename a4T,
267  typename a5T>
268  inline typename enable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
269  run_function(Future<void>& result, fnT fn, a1T& a1, a2T& a2,
270  a3T& a3, a4T& a4, a5T& a5, const voidT&, const voidT&,
271  const voidT&, const voidT&)
272  { fn(a1, a2, a3, a4, a5); result.set(); }
273 
274  template <typename fnT, typename a1T, typename a2T, typename a3T, typename a4T,
275  typename a5T, typename a6T>
276  inline typename enable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
277  run_function(Future<void>& result, fnT fn, a1T& a1, a2T& a2,
278  a3T& a3, a4T& a4, a5T& a5, a6T& a6, const voidT&, const voidT&,
279  const voidT&)
280  { fn(a1, a2, a3, a4, a5, a6); result.set(); }
281 
282  template <typename fnT, typename a1T, typename a2T, typename a3T, typename a4T,
283  typename a5T, typename a6T, typename a7T>
284  inline typename enable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
285  run_function(Future<void>& result, fnT fn, a1T& a1, a2T& a2,
286  a3T& a3, a4T& a4, a5T& a5, a6T& a6, a7T& a7, const voidT&,
287  const voidT&)
288  { fn(a1, a2, a3, a4, a5, a6, a7); result.set(); }
289 
290  template <typename fnT, typename a1T, typename a2T, typename a3T, typename a4T,
291  typename a5T, typename a6T, typename a7T, typename a8T>
292  inline typename enable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
293  run_function(Future<void>& result, fnT fn, a1T& a1, a2T& a2,
294  a3T& a3, a4T& a4, a5T& a5, a6T& a6, a7T& a7, a8T& a8, const voidT&)
295  { fn(a1, a2, a3, a4, a5, a6, a7, a8); result.set(); }
296 
297  template <typename fnT, typename a1T, typename a2T, typename a3T, typename a4T,
298  typename a5T, typename a6T, typename a7T, typename a8T, typename a9T>
299  inline typename enable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
300  run_function(Future<void>& result, fnT fn, a1T& a1, a2T& a2,
301  a3T& a3, a4T& a4, a5T& a5, a6T& a6, a7T& a7, a8T& a8, a9T& a9)
302  { fn(a1, a2, a3, a4, a5, a6, a7, a8, a9); result.set(); }
303 
304  template <typename fnT>
305  inline typename disable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
306  run_function(typename task_result_type<fnT>::futureT& result,
307  fnT fn, const voidT&, const voidT&, const voidT&, const voidT&,
308  const voidT&, const voidT&, const voidT&, const voidT&, const voidT&)
309  { result.set(fn()); }
310 
311  template <typename fnT, typename a1T>
312  inline typename disable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
313  run_function(typename task_result_type<fnT>::futureT& result,
314  fnT fn, a1T& a1, const voidT&, const voidT&, const voidT&,
315  const voidT&, const voidT&, const voidT&, const voidT&, const voidT&)
316  { result.set(fn(a1)); }
317 
318  template <typename fnT, typename a1T, typename a2T>
319  inline typename disable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
320  run_function(typename task_result_type<fnT>::futureT& result,
321  fnT fn, a1T& a1, a2T& a2, const voidT&, const voidT&, const voidT&,
322  const voidT&, const voidT&, const voidT&, const voidT&)
323  { result.set(fn(a1, a2)); }
324 
325  template <typename fnT, typename a1T, typename a2T, typename a3T>
326  inline typename disable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
327  run_function(typename task_result_type<fnT>::futureT& result,
328  fnT fn, a1T& a1, a2T& a2, a3T& a3, const voidT&, const voidT&,
329  const voidT&, const voidT&, const voidT&, const voidT&)
330  { result.set(fn(a1, a2, a3)); }
331 
332  template <typename fnT, typename a1T, typename a2T, typename a3T, typename a4T>
333  inline typename disable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
334  run_function(typename task_result_type<fnT>::futureT& result,
335  fnT fn, a1T& a1, a2T& a2, a3T& a3, a4T& a4, const voidT&,
336  const voidT&, const voidT&, const voidT&, const voidT&)
337  { result.set(fn(a1, a2, a3, a4)); }
338 
339  template <typename fnT, typename a1T, typename a2T, typename a3T, typename a4T,
340  typename a5T>
341  inline typename disable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
342  run_function(typename task_result_type<fnT>::futureT& result,
343  fnT fn, a1T& a1, a2T& a2, a3T& a3, a4T& a4, a5T& a5, const voidT&,
344  const voidT&, const voidT&, const voidT&)
345  { result.set(fn(a1, a2, a3, a4, a5)); }
346 
347  template <typename fnT, typename a1T, typename a2T, typename a3T, typename a4T,
348  typename a5T, typename a6T>
349  inline typename disable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
350  run_function(typename task_result_type<fnT>::futureT& result,
351  fnT fn, a1T& a1, a2T& a2, a3T& a3, a4T& a4, a5T& a5, a6T& a6,
352  const voidT&, const voidT&, const voidT&)
353  { result.set(fn(a1, a2, a3, a4, a5, a6)); }
354 
355  template <typename fnT, typename a1T, typename a2T, typename a3T, typename a4T,
356  typename a5T, typename a6T, typename a7T>
357  inline typename disable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
358  run_function(typename task_result_type<fnT>::futureT& result,
359  fnT fn, a1T& a1, a2T& a2, a3T& a3, a4T& a4, a5T& a5, a6T& a6,
360  a7T& a7, const voidT&, const voidT&)
361  { result.set(fn(a1, a2, a3, a4, a5, a6, a7)); }
362 
363  template <typename fnT, typename a1T, typename a2T, typename a3T, typename a4T,
364  typename a5T, typename a6T, typename a7T, typename a8T>
365  inline typename disable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
366  run_function(typename task_result_type<fnT>::futureT& result,
367  fnT fn, a1T& a1, a2T& a2, a3T& a3, a4T& a4, a5T& a5, a6T& a6,
368  a7T& a7, a8T& a8, const voidT&)
369  { result.set(fn(a1, a2, a3, a4, a5, a6, a7, a8)); }
370 
371  template <typename fnT, typename a1T, typename a2T, typename a3T, typename a4T,
372  typename a5T, typename a6T, typename a7T, typename a8T, typename a9T>
373  inline typename disable_if<std::is_void<typename detail::result_of<fnT>::type> >::type
374  run_function(typename task_result_type<fnT>::futureT& result,
375  fnT fn, a1T& a1, a2T& a2, a3T& a3, a4T& a4, a5T& a5, a6T& a6,
376  a7T& a7, a8T& a8, a9T& a9)
377  { result.set(fn(a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
378 
379  } // namespace detail
380 
382 
384  template <typename fnT, typename arg1T = void, typename arg2T = void,
385  typename arg3T = void, typename arg4T = void, typename arg5T = void,
386  typename arg6T = void, typename arg7T = void, typename arg8T = void,
387  typename arg9T = void>
388  struct TaskFn : public TaskInterface {
389  private:
391  typedef TaskFn<fnT, arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T,
392  arg8T, arg9T> TaskFn_;
393 
394  public:
395 
396  typedef fnT functionT;
397  typedef typename detail::task_result_type<fnT>::resultT resultT;
399  typedef typename detail::task_result_type<fnT>::futureT futureT;
400 
401  // argument value typedefs
402 
403  static const unsigned int arity = detail::ArgCount<arg1T, arg2T, arg3T,
404  arg4T, arg5T, arg6T, arg7T, arg8T, arg9T>::value;
408 
409  private:
410  futureT result_;
411  const functionT func_;
412 
413  // If the value of the argument is known at the time the
414  // Note: The type argNT for argN, where N is > arity should be void
415 
416  typename detail::task_arg<arg1T>::holderT arg1_;
417  typename detail::task_arg<arg2T>::holderT arg2_;
418  typename detail::task_arg<arg3T>::holderT arg3_;
419  typename detail::task_arg<arg4T>::holderT arg4_;
420  typename detail::task_arg<arg5T>::holderT arg5_;
421  typename detail::task_arg<arg6T>::holderT arg6_;
422  typename detail::task_arg<arg7T>::holderT arg7_;
423  typename detail::task_arg<arg8T>::holderT arg8_;
424  typename detail::task_arg<arg9T>::holderT arg9_;
425 
426  template <typename fT>
427  static fT& get_func(fT& f) { return f; }
428 
429  template <typename ptrT, typename memfnT, typename resT>
430  static memfnT get_func(const detail::MemFuncWrapper<ptrT, memfnT, resT>& wrapper) {
431  return detail::get_mem_func_ptr(wrapper);
432  }
433 
434  virtual void get_id(std::pair<void*,unsigned short>& id) const {
435  return make_id(id, get_func(func_));
436  }
437 
438 
440 
443  template <typename T>
444  inline void check_dependency(Future<T>& fut) {
445  if(!fut.probe()) {
446  DependencyInterface::inc();
447  fut.register_callback(this);
448  }
449  }
450 
451 
453  template <typename T>
454  inline void check_dependency(detail::ArgHolder<std::vector<Future<T> > >& arg) {
455  check_dependency(static_cast<std::vector<Future<T> >&>(arg));
456  }
457 
459  template <typename T>
460  inline void check_dependency(std::vector<Future<T> >& vec) {
461  for(typename std::vector<Future<T> >::iterator it = vec.begin(); it != vec.end(); ++it)
462  check_dependency(*it);
463  }
464 
466  inline void check_dependency(const std::vector<Future<void> >&) { }
467 
469  template <typename T>
470  inline void check_dependency(const detail::ArgHolder<T>&) { }
471 
473  inline void check_dependency(const Future<void>&) { }
474 
476  inline void check_dependency(const Future<Void>&) { }
477 
479  void check_dependencies() {
480  check_dependency(arg1_);
481  check_dependency(arg2_);
482  check_dependency(arg3_);
483  check_dependency(arg4_);
484  check_dependency(arg5_);
485  check_dependency(arg6_);
486  check_dependency(arg7_);
487  check_dependency(arg8_);
488  check_dependency(arg9_);
489  }
490 
491  // Copies are not allowed.
492  TaskFn(const TaskFn_&);
493  TaskFn_ operator=(TaskFn_&);
494 
495  public:
496 
497  TaskFn(const futureT& result, functionT func, const TaskAttributes& attr) :
498  TaskInterface(attr), result_(result), func_(func), arg1_(), arg2_(),
499  arg3_(), arg4_(), arg5_(), arg6_(), arg7_(), arg8_(), arg9_()
500  {
501  MADNESS_ASSERT(arity == 0u);
502  check_dependencies();
503  }
504 
505  template <typename a1T>
506  TaskFn(const futureT& result, functionT func, const a1T& a1,
507  const TaskAttributes& attr) :
508  TaskInterface(attr), result_(result), func_(func), arg1_(a1), arg2_(),
509  arg3_(), arg4_(), arg5_(), arg6_(), arg7_(), arg8_(), arg9_()
510  {
511  MADNESS_ASSERT(arity == 1u);
512  check_dependencies();
513  }
514 
515  template <typename a1T, typename a2T>
516  TaskFn(const futureT& result, functionT func, const a1T& a1, const a2T& a2,
517  const TaskAttributes& attr = TaskAttributes()) :
518  TaskInterface(attr), result_(result), func_(func), arg1_(a1), arg2_(a2),
519  arg3_(), arg4_(), arg5_(), arg6_(), arg7_(), arg8_(), arg9_()
520  {
521  MADNESS_ASSERT(arity == 2u);
522  check_dependencies();
523  }
524 
525  template <typename a1T, typename a2T, typename a3T>
526  TaskFn(const futureT& result, functionT func, const a1T& a1, const a2T& a2,
527  const a3T& a3, const TaskAttributes& attr) :
528  TaskInterface(attr), result_(result), func_(func), arg1_(a1), arg2_(a2),
529  arg3_(a3), arg4_(), arg5_(), arg6_(), arg7_(), arg8_(), arg9_()
530  {
531  MADNESS_ASSERT(arity == 3u);
532  check_dependencies();
533  }
534 
535  template <typename a1T, typename a2T, typename a3T, typename a4T>
536  TaskFn(const futureT& result, functionT func, const a1T& a1, const a2T& a2,
537  const a3T& a3, const a4T& a4, const TaskAttributes& attr) :
538  TaskInterface(attr), result_(result), func_(func), arg1_(a1), arg2_(a2),
539  arg3_(a3), arg4_(a4), arg5_(), arg6_(), arg7_(), arg8_(), arg9_()
540  {
541  MADNESS_ASSERT(arity == 4u);
542  check_dependencies();
543  }
544 
545  template <typename a1T, typename a2T, typename a3T, typename a4T, typename a5T>
546  TaskFn(const futureT& result, functionT func, const a1T& a1, const a2T& a2,
547  const a3T& a3, const a4T& a4, const a5T& a5, const TaskAttributes& attr) :
548  TaskInterface(attr), result_(result), func_(func), arg1_(a1), arg2_(a2),
549  arg3_(a3), arg4_(a4), arg5_(a5), arg6_(), arg7_(), arg8_(), arg9_()
550  {
551  MADNESS_ASSERT(arity == 5u);
552  check_dependencies();
553  }
554 
555  template <typename a1T, typename a2T, typename a3T, typename a4T, typename a5T,
556  typename a6T>
557  TaskFn(const futureT& result, functionT func, const a1T& a1, const a2T& a2,
558  const a3T& a3, const a4T& a4, const a5T& a5, const a6T& a6,
559  const TaskAttributes& attr) :
560  TaskInterface(attr), result_(result), func_(func), arg1_(a1), arg2_(a2),
561  arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6), arg7_(), arg8_(), arg9_()
562  {
563  MADNESS_ASSERT(arity == 6u);
564  check_dependencies();
565  }
566 
567  template <typename a1T, typename a2T, typename a3T, typename a4T, typename a5T,
568  typename a6T, typename a7T>
569  TaskFn(const futureT& result, functionT func, const a1T& a1, const a2T& a2,
570  const a3T& a3, const a4T& a4, const a5T& a5, const a6T& a6,
571  const a7T& a7, const TaskAttributes& attr) :
572  TaskInterface(attr), result_(result), func_(func), arg1_(a1), arg2_(a2),
573  arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6), arg7_(a7), arg8_(), arg9_()
574  {
575  MADNESS_ASSERT(arity == 7u);
576  check_dependencies();
577  }
578 
579  template <typename a1T, typename a2T, typename a3T, typename a4T, typename a5T,
580  typename a6T, typename a7T, typename a8T>
581  TaskFn(const futureT& result, functionT func, const a1T& a1, const a2T& a2,
582  const a3T& a3, const a4T& a4, const a5T& a5, const a6T& a6, const a7T& a7,
583  const a8T& a8, const TaskAttributes& attr) :
584  TaskInterface(attr), result_(result), func_(func), arg1_(a1), arg2_(a2),
585  arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6), arg7_(a7), arg8_(a8), arg9_()
586  {
587  MADNESS_ASSERT(arity == 8u);
588  check_dependencies();
589  }
590 
591  template <typename a1T, typename a2T, typename a3T, typename a4T, typename a5T,
592  typename a6T, typename a7T, typename a8T, typename a9T>
593  TaskFn(const futureT& result, functionT func, const a1T& a1, const a2T& a2,
594  const a3T& a3, const a4T& a4, const a5T& a5, const a6T& a6,
595  const a7T& a7, const a8T& a8, const a9T& a9, const TaskAttributes& attr) :
596  TaskInterface(attr), result_(result), func_(func), arg1_(a1), arg2_(a2),
597  arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6), arg7_(a7), arg8_(a8), arg9_(a9)
598  {
599  MADNESS_ASSERT(arity == 9u);
600  check_dependencies();
601  }
602 
603  TaskFn(const futureT& result, functionT func, const TaskAttributes& attr,
604  archive::BufferInputArchive& input_arch) :
605  TaskInterface(attr), result_(result), func_(func), arg1_(input_arch),
606  arg2_(input_arch), arg3_(input_arch), arg4_(input_arch), arg5_(input_arch),
607  arg6_(input_arch), arg7_(input_arch), arg8_(input_arch), arg9_(input_arch)
608  {
609  // No need to check dependencies since the arguments are from an archive
610  }
611 
612  virtual ~TaskFn() { }
613 
614  const futureT& result() const { return result_; }
615 
616 
617 #ifdef HAVE_INTEL_TBB
618  virtual tbb::task* execute() {
619  detail::run_function(result_, func_, arg1_, arg2_, arg3_, arg4_,
620  arg5_, arg6_, arg7_, arg8_, arg9_);
621  return NULL;
622  }
623 #else
624  protected:
625  virtual void run(const TaskThreadEnv& env) {
626  detail::run_function(result_, func_, arg1_, arg2_, arg3_, arg4_,
627  arg5_, arg6_, arg7_, arg8_, arg9_);
628  }
629 #endif // HAVE_INTEL_TBB
630 
631  }; // class TaskFn
632 
633 } // namespace madness
634 
635 
636 #endif // MADNESS_WORLD_TASKFN_H__INCLUDED
madness::detail::task_arg< Future< void > >::type
const Future< void > type
Definition: taskfn.h:203
func
std::complex< double > func(int n, int t1, int t2, int t3, double xx, double yy, double zz)
Definition: wannier.cc:98
madness::detail::task_result_type::type
futureT type
Definition: taskfn.h:217
madness::TaskInterface::TaskInterface
TaskInterface(const TaskAttributes &attr)
Create a new task with zero dependencies and given attributes.
Definition: taskfn.h:112
madness::DependencyInterface::inc
void inc()
Increment the number of dependencies.
Definition: worlddep.h:108
madness::detail::ArgCountHelper
Definition: taskfn.h:150
madness::detail::ArgHolder::ArgHolder
ArgHolder(const Arg &arg)
Definition: taskfn.h:177
madness::detail::task_arg::holderT
ArgHolder< T > holderT
Definition: taskfn.h:192
madness::DependencyInterface::notify
void notify()
Invoked by callbacks to notifiy of dependencies being satisfied.
Definition: worlddep.h:91
madness::detail::task_arg< void >::type
const Future< void > type
Definition: taskfn.h:209
madness::detail::task_arg< void >::holderT
const Future< void > holderT
Definition: taskfn.h:210
madness::TaskInterface::TaskInterface
TaskInterface(int ndepend=0, const TaskAttributes attr=TaskAttributes())
Create a new task with ndepend dependencies (default 0) and given attributes.
Definition: taskfn.h:103
madness::TaskFn::TaskFn
TaskFn(const futureT &result, functionT func, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const a5T &a5, const a6T &a6, const TaskAttributes &attr)
Definition: taskfn.h:557
madness::TaskThreadEnv
Used to pass info about thread environment into users task.
Definition: worldthread.h:289
madness::CallbackInterface
This class used for callbacks (e.g., for dependency tracking)
Definition: worlddep.h:51
madness::detail::task_arg< Future< void > >::holderT
const Future< void > holderT
Definition: taskfn.h:204
madness::Future< void >
Specialization of Future for internal convenience ... does nothing useful!
Definition: worldfut.h:598
madness::TaskFn::TaskFn
TaskFn(const futureT &result, functionT func, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const a5T &a5, const a6T &a6, const a7T &a7, const a8T &a8, const TaskAttributes &attr)
Definition: taskfn.h:581
madness::Future< void >::set
static void set(const Future< void > &)
Definition: worldfut.h:616
madness::TaskFn::TaskFn
TaskFn(const futureT &result, functionT func, const TaskAttributes &attr, archive::BufferInputArchive &input_arch)
Definition: taskfn.h:603
madness::f
NDIM & f
Definition: mra.h:2179
worldfut.h
Implements Future.
madness::TaskFn::TaskFn
TaskFn(const futureT &result, functionT func, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const TaskAttributes &attr)
Definition: taskfn.h:536
madness::TaskFn::TaskFn
TaskFn(const futureT &result, functionT func, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const a5T &a5, const TaskAttributes &attr)
Definition: taskfn.h:546
madness::disable_if
disable_if from Boost for conditionally instantiating templates based on type
Definition: enable_if.h:78
madness::arg
Tensor< typename Tensor< T >::scalar_type > arg(const Tensor< T > &t)
Return a new tensor holding the argument of each element of t (complex types only) ...
Definition: tensor.h:2429
madness::WorldTaskQueue
Multi-threaded queue to manage and run tasks.
Definition: worldtask.h:393
madness::PoolTaskInterface
Lowest level task interface.
Definition: worldthread.h:636
madness::TaskInterface::~TaskInterface
virtual ~TaskInterface()
Definition: taskfn.h:143
madness::TaskInterface::run
virtual void run(World &world, const TaskThreadEnv &env)
Runs a multi-threaded task.
Definition: taskfn.h:134
madness::detail::task_arg::type
T type
Definition: taskfn.h:191
madness::detail::task_arg
Definition: taskfn.h:190
a2
const double a2
Definition: vnucso.cc:91
madness::detail::task_result_type::resultT
madness::remove_fcvr< typename madness::detail::result_of< fnT >::type >::type resultT
Definition: taskfn.h:215
madness::TaskFn::arity
static const unsigned int arity
Definition: taskfn.h:403
madness::detail::ArgCountHelper::value
static const unsigned int value
Definition: taskfn.h:151
madness::detail::run_function
enable_if< std::is_void< typename detail::result_of< fnT >::type > >::type run_function(Future< void > &result, fnT fn, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &, const voidT &)
Definition: taskfn.h:233
std::tr1::T
const T1 &f1 return GTEST_2_TUPLE_() T(f0, f1)
madness::DependencyInterface
Provides interface for tracking dependencies.
Definition: worlddep.h:60
madness::vec
Vector< T, 1 > vec(T x)
Your friendly neighborhood factory function.
Definition: array.h:456
madness::ThreadPool::add
static void add(PoolTaskInterface *task)
Add a new task to the pool.
Definition: worldthread.h:984
madness::TaskFn::TaskFn
TaskFn(const futureT &result, functionT func, const a1T &a1, const TaskAttributes &attr)
Definition: taskfn.h:506
madness::TaskInterface::debug
static bool debug
Definition: taskfn.h:100
madness::TaskInterface::get_world
World * get_world() const
Definition: taskfn.h:141
madness::detail::voidT
Future< void > voidT
Definition: taskfn.h:222
worldthread.h
Implements Dqueue, Thread, ThreadBase and ThreadPool.
madness::TaskInterface::run
virtual void run(const TaskThreadEnv &env)
Override this method to implement a multi-threaded task.
Definition: worldtask.cc:44
madness::detail::ArgCount
Definition: taskfn.h:162
madness::TaskFn::TaskFn
TaskFn(const futureT &result, functionT func, const a1T &a1, const a2T &a2, const TaskAttributes &attr=TaskAttributes())
Definition: taskfn.h:516
madness::TaskFn::TaskFn
TaskFn(const futureT &result, functionT func, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const a5T &a5, const a6T &a6, const a7T &a7, const TaskAttributes &attr)
Definition: taskfn.h:569
madness::TaskFn::~TaskFn
virtual ~TaskFn()
Definition: taskfn.h:612
madness::TaskThreadEnv::nthread
int nthread() const
Definition: worldthread.h:307
madness::World
A parallel world with full functionality wrapping an MPI communicator.
Definition: worldfwd.h:416
madness::detail::task_result_type
Definition: taskfn.h:214
madness::TaskFn
Wrap a callable object and its arguments into a task function.
Definition: taskfn.h:388
madness::archive::BufferInputArchive
Wraps an archive around a memory buffer for input.
Definition: bufar.h:206
madness::TaskAttributes::TaskAttributes
TaskAttributes(unsigned long flags=0)
Definition: worldthread.h:216
madness::TaskAttributes
Contains attributes of a task.
Definition: worldthread.h:208
a1
const double a1
Definition: vnucso.cc:90
madness::remove_fcvr
Definition: typestuff.h:77
madness::PoolTaskInterface::make_id
static enable_if_c< detail::function_traits< fnT >::value||detail::memfunc_traits< fnT >::value >::type make_id(std::pair< void *, unsigned short > &id, fnT fn)
Definition: worldthread.h:680
madness::detail::MemFuncWrapper
Definition: taskfn.h:50
madness::TaskFn::functionT
fnT functionT
The task function type.
Definition: taskfn.h:396
madness::Future
A future is a possibly yet unevaluated value.
Definition: ref.h:210
madness::TaskFn::TaskFn
TaskFn(const futureT &result, functionT func, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const a5T &a5, const a6T &a6, const a7T &a7, const a8T &a8, const a9T &a9, const TaskAttributes &attr)
Definition: taskfn.h:593
madness::TaskInterface::run
virtual void run(World &)
Runs a single-threaded task ... derived classes must implement this.
Definition: taskfn.h:128
madness::TaskFn::resultT
detail::task_result_type< fnT >::resultT resultT
The result type of the function.
Definition: taskfn.h:397
madness::tr1::integral_constant
Definition: integral_constant.h:7
madness::detail::ArgHolder::ArgHolder
ArgHolder(const archive::BufferInputArchive &input_arch)
Definition: taskfn.h:179
MADNESS_EXCEPTION
#define MADNESS_EXCEPTION(msg, value)
Definition: worldexc.h:88
madness::TaskInterface
All world tasks must be derived from this public interface.
Definition: taskfn.h:68
madness::TaskFn::run
virtual void run(const TaskThreadEnv &env)
Override this method to implement a multi-threaded task.
Definition: taskfn.h:625
madness::Future::set
void set(const Future< T > &other)
A.set(B) where A & B are futures ensures A has/will have the same value as B.
Definition: worldfut.h:473
madness::TaskFn::result
const futureT & result() const
Definition: taskfn.h:614
madness::detail::task_arg< Future< T > >::holderT
Future< T > holderT
Definition: taskfn.h:198
madness::detail::task_arg< Future< T > >::type
T type
Definition: taskfn.h:197
madness::enable_if
enable_if from Boost for conditionally instantiating templates based on type
Definition: enable_if.h:60
madness
Holds machinery to set up Functions/FuncImpls using various Factories and Interfaces.
Definition: chem/atomutil.cc:45
madness::TaskFn::futureT
detail::task_result_type< fnT >::futureT futureT
Definition: taskfn.h:399
c
const double c
Definition: gfit.cc:200
madness::detail::ArgHolder
A wrapper object for holding task function objects.
Definition: taskfn.h:172
madness::TaskFn::TaskFn
TaskFn(const futureT &result, functionT func, const a1T &a1, const a2T &a2, const a3T &a3, const TaskAttributes &attr)
Definition: taskfn.h:526
madness::CallbackInterface::notify
virtual void notify()=0
madness::DependencyInterface::register_callback
void register_callback(CallbackInterface *callback)
Registers a callback for when ndepend==0 , immediately invoked if ndepend==0.
Definition: worlddep.h:94
madness::TaskFn::TaskFn
TaskFn(const futureT &result, functionT func, const TaskAttributes &attr)
Definition: taskfn.h:497
worlddep.h
Defines DependencyInterface and CallbackInterface.
madness::detail::get_mem_func_ptr
memfnT get_mem_func_ptr(const MemFuncWrapper< ptrT, memfnT, resT > &)
Definition: worldtask.h:385
NO_DEFAULTS
Disables default copy constructor and assignment operators.
Definition: nodefaults.h:49
madness::detail::task_result_type::futureT
Future< resultT > futureT
Definition: taskfn.h:216
Generated on Fri Sep 26 2014 10:38:58 for MADNESS by   doxygen 1.8.8