/Users/mourrain/Devel/mmx/algebramix/include/algebramix/vector_threads.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : vector_threads.hpp
* DESCRIPTION: multi-threaded vector operations
* COPYRIGHT  : (C) 2007  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#ifndef __MMX__VECTOR_THREADS__HPP
#define __MMX__VECTOR_THREADS__HPP
#include <algebramix/vector_unrolled.hpp>
#include <basix/threads.hpp>

namespace mmx {
#define TMPL  template<typename C>
#define TMPLX template<typename C, typename X>

/******************************************************************************
* Variant for threads
******************************************************************************/

template<typename V>
struct vector_threads: public V {
  typedef typename V::Naive Naive;
  typedef vector_threads<typename V::Aligned> Aligned;
  typedef vector_threads<typename V::No_simd> No_simd;
  typedef typename V::No_thread No_thread;
};

template<typename F, typename V, typename W>
struct implementation<F,V,vector_threads<W> >:
  public implementation<F,V,W> {};

/******************************************************************************
* Multi-threaded routines on vectors
******************************************************************************/

template<typename V, typename W>
struct implementation<vector_abstractions,V,vector_threads<W> >:
    public implementation<vector_allocate,V>,
    public implementation<vector_abstractions,W> 
{
  typedef implementation<vector_abstractions,W> Vec;

template<typename Op, typename C>
struct unary_task_rep: public task_rep {
  C* dest; const C* s; nat n;
public:
  inline unary_task_rep (C* dest2, const C* s2, nat n2):
    dest (dest2), s (s2), n (n2) {}
  void execute () { Vec::template unary<Op> (dest, s, n); }
};

template<typename Op, typename C> static inline void
unary (C* dest, const C* s, nat n) {
  if (n < 256) Vec::template unary<Op> (dest, s, n);
  else {
    task ts[threads_number];
    for (nat id=0; id<threads_number; id++) {
      nat i1= (id*n)     / threads_number;
      nat i2= ((id+1)*n) / threads_number;
      ts[id]= new unary_task_rep<Op,C> (dest + i1, s + i1, i2 - i1);
    }
    threads_execute (ts, threads_number);
    for (nat id=0; id<threads_number; id++)
      delete ts[id];
  }
}

template<typename Op, typename C>
struct binary_task_rep: public task_rep {
  C* dest; const C* s1; const C* s2; nat n;
public:
  inline binary_task_rep (C* dest2, const C* s1b, const C* s2b, nat n2):
    dest (dest2), s1 (s1b), s2 (s2b), n (n2) {}
  void execute () { Vec::template binary<Op> (dest, s1, s2, n); }
};

template<typename Op, typename C> static inline void
binary (C* dest, const C* s1, const C* s2, nat n) {
  if (n < 256) Vec::template binary<Op> (dest, s1, s2, n);
  else {
    task ts[threads_number];
    for (nat id=0; id<threads_number; id++) {
      nat i1= (id*n)     / threads_number;
      nat i2= ((id+1)*n) / threads_number;
      ts[id]= new binary_task_rep<Op,C> (dest + i1, s1 + i1, s2 + i1, i2 - i1);
    }
    threads_execute (ts, threads_number);
  }
}

}; // implementation<vector_abstractions,V,vector_threads<W> >

#undef TMPL
#undef TMPLX
} // namespace mmx
#endif //__MMX__VECTOR_THREADS__HPP