+ View the NASA Portal

Search JPL

Search CLARAty

- Algorithms- Infrastructure - Doxygen (public)- Doxygen (private)- Tutorials

- Repository- Nightly Build- Nightly Regression- Feature/Bug Tracking- Build Targets- Procedure- Conventions- Tools

background_thread.h

Go to the documentation of this file.

// -*-c++-*-
//----------------------------< /-/ CLARAty /-/ >------------------------------
/**
 * @file  background_thread.h
 *
 * Helper classes for background thread
 * 
 * <br>@b Designer(s):  Clayton Kunz
 * <br>@b Author(s):    Clayton Kunz
 * <br>@b Date:         February 2, 2004
 *
 * <b>Software License:</b><br>
 * <code> http://claraty.jpl.nasa.gov/license/open_src/  or 
 *        file: license/open_src.txt </code>
 * 
 * &copy; 2006, Jet Propulsion Laboratory, California Institute of Technology
 * 
 * $Revision: 1.1 $
 */
//-----------------------------------------------------------------------------

#ifndef BACKGROUND_THREAD_H
#define BAKCGROUND_THREAD_H

#include "claraty/share.h"
#include <ace/Thread_Manager.h>
#include <assert.h>

#include "claraty/functor.h"

#include <memory>

namespace claraty {

class BG_Task {
public:
  BG_Task() { }
  virtual ~BG_Task() { }
  virtual void wait() { }
};

template <class Op, class ret>
class bg_helper {
  Op fn;
  ACE_thread_t& thread_id;
  ret& return_value;

  explicit bg_helper(const bg_helper& rhs);

  static ACE_THR_FUNC_RETURN dispatch(void *arg) {
    bg_helper *mgr = static_cast<bg_helper*>(arg);
    mgr->return_value = mgr->fn();
    delete mgr;
    return 0;
  }

public:
  bg_helper(Op op, ret& return_var, ACE_thread_t& tid, bool detach = false)
    : fn(op), thread_id(tid), return_value(return_var)
  {
    ACE_Thread_Manager *tm = ACE_Thread_Manager::instance();
    long flags = THR_NEW_LWP;
    if (!detach)
      flags |= THR_JOINABLE;
    tm->spawn(dispatch, this, flags, &thread_id);
  }

  ~bg_helper() { }
};

template <class Op>
class bg_void_helper {
  Op fn;
  ACE_thread_t& thread_id;

  explicit bg_void_helper(const bg_void_helper& rhs);

  static ACE_THR_FUNC_RETURN dispatch(void *arg) {
    bg_void_helper *mgr = static_cast<bg_void_helper*>(arg);
    mgr->fn();
    delete mgr;
    return 0;
  }

public:
  bg_void_helper(Op op, ACE_thread_t& tid, bool detach = false)
    : fn(op), thread_id(tid)
  {
    ACE_Thread_Manager *tm = ACE_Thread_Manager::instance();
    long flags = THR_NEW_LWP;
    if (!detach)
      flags |= THR_JOINABLE;
    tm->spawn(dispatch, this, flags, &thread_id);
  }

  ~bg_void_helper() { }
};


template <class result_type>
class bg : public BG_Task {
  ACE_thread_t thread_id;
  result_type& return_value;

  explicit bg(const bg& rhs);

protected:
  bool detached;
public:
  template <class Op>
  bg(Op op, result_type& return_var, bool detach = false)
    : BG_Task(), 
      // ACE_thread_t must be initialized to 0 for VxWorks 
      // (undocumented in ACE)
      thread_id (0),
      return_value(return_var), detached(detach)
  {
    new bg_helper<Op, result_type>(op, return_var, thread_id, detach);
  }

  virtual ~bg() {
    if (!detached)
      wait();
  }

  virtual void wait() {
    assert(!detached);
    ACE_Thread_Manager *tm = ACE_Thread_Manager::instance();
    tm->join(thread_id);
    detached = true;
  }
};

template<> class bg<void> : public BG_Task {
  ACE_thread_t thread_id;

  explicit bg(const bg& rhs);

protected:
  bool detached;
public:
  template <class Op>
  bg(Op op, bool detach = false)
    : BG_Task(), 
      // ACE_thread_t must be initialized to 0 for VxWorks 
      // (undocumented in ACE)
      thread_id (0),
      detached(detach)
  {
    new bg_void_helper<Op>(op, thread_id, detach);
  }

  virtual ~bg() {
    if (!detached)
      wait();
  }

  virtual void wait() {
    assert(!detached);
    ACE_Thread_Manager *tm = ACE_Thread_Manager::instance();
    tm->join(thread_id);
    detached = true;
  }
};

template <class ret_type>
class auto_bg : public bg<ret_type>, public VFunctor0_const<bool> {
  bool time_to_quit;
  
  template <class Op>
  struct quittable_functor {
    const auto_bg<ret_type>& quit_functor;
    Op op;
    quittable_functor(Op& o, const auto_bg<ret_type>& func)
      : quit_functor(func), op(o) { }
    
    ret_type operator()() { return op(quit_functor); }
  };

public:
  template <class Op>
  auto_bg(Op op, ret_type& return_var, bool detach = false)
    : bg<ret_type>(quittable_functor<Op>(op, *this), return_var, detach),
      time_to_quit(false)
  { }

  virtual ~auto_bg() {
    if (!this->detached)
      wait();
  }

  virtual void wait() {
    time_to_quit = true;
    bg<ret_type>::wait();
  }

  virtual bool operator()() const { return time_to_quit; }
};

template<> class auto_bg<void> : public bg<void>, public VFunctor0_const<bool> {
  bool time_to_quit;

  template <class Op>
  struct quittable_functor {
    const auto_bg<void>& quit_functor;
    Op op;
    quittable_functor(Op& o, const auto_bg<void>& func)
      : quit_functor(func), op(o) { }

    void operator()() { op(quit_functor); }
  };

public:
  template <class Op>
  auto_bg(Op op, bool detach = false)
    : bg<void>(quittable_functor<Op>(op, *this), detach), time_to_quit(false)
  { }

  virtual ~auto_bg() {
    if (!detached)
      wait();
  }

  virtual void wait() {
    time_to_quit = true;
    bg<void>::wait();
  }

  virtual bool operator()() const { return time_to_quit; }
};

template <class Op, class res_type>
std::auto_ptr<BG_Task> background(Op op, res_type& retval,
                                  bool detach = false) {
  return std::auto_ptr<BG_Task>(new bg<res_type>(op, retval, detach));
}

template <class Op>
std::auto_ptr<BG_Task> background(Op op, bool detach = false) {
  return std::auto_ptr<BG_Task>(new bg<void>(op, detach));
}

/**
   Silly helper class + function for spawning a member function taking
   8 arguments and returning a value. This was written specifically
   with the ARC disparity correlator function call in mind, to do
   forward and backward correlation simultaneously. */
template <class T, class R, class A, class B, class C, class D, class E, class F, class G, class H>
struct big_8 {
  A _a;
  B _b;
  C _c;
  D _d;
  E _e;
  F _f;
  G _g;
  H _h;

  T *const object;
  R (T::*fn)(A, B, C, D, E, F, G, H);

  typedef R result_type;

  big_8(T *const obj, R (T::*func)(A, B, C, D, E, F, G, H),
        A a, B b, C c, D d, E e, F f, G g, H h)
    : _a(a), _b(b), _c(c), _d(d), _e(e), _f(f), _g(g), _h(h), object(obj),
      fn(func)
  { }

  R operator()() {
    return (object->*fn)(_a, _b, _c, _d, _e, _f, _g, _h);
  }
};

template <class T, class R, class A, class B, class C, class D, class E, class F, class G, class H>
big_8<T, R, A, B, C, D, E, F, G, H>
compos8(T *const obj, R (T::*func)(A, B, C, D, E, F, G, H),
        A a, B b, C c, D d, E e, F f, G g, H h)
{
  return big_8<T, R, A, B, C, D, E, F, G, H>
    (obj, func, a, b, c, d, e, f, g, h);
}

} // namespace claraty

#endif

Last modified: June 05 2007 10:19:53

JPL PRIVACY STATEMENT GLOSSARY SITEMAP FEEDBACK CONTACT US

Site Manager: Issa A.D. Nesnas
Site Maintainer: Kelly Breed
Document Clearance #: CL 07-0635