parallel.h

#pragma once
#include "math/parallelacc.h"
#include "math/parallelcu.h"
#include "tool/externfunc.h"
#include "tool/macro.h"
 
namespace tinker {
template <class T>
T reduceSum(const T* gpu_a, size_t nelem, int queue)
{
   // TINKER_FVOID2(acc1, cu1, T, reduceSum, const T*, size_t, int);
   return TINKER_FCALL2(acc1, cu1, reduceSum, gpu_a, nelem, queue);
}
 
template <class HT, size_t HN, class DPTR>
void reduceSum2(HT (&h_ans)[HN], DPTR v, size_t nelem, int queue)
{
   // TINKER_FVOID2(acc1, cu1, HT (&)[HN], DPTR, size_t, int);
   TINKER_FCALL2(acc1, cu1, reduceSum2, h_ans, v, nelem, queue);
}
 
template <class T>
void reduceSumOnDevice(T* dp_ans, const T* a, size_t nelem, int queue)
{
   // TINKER_FVOID2(acc1, cu1, reduceSumOnDevice, T*, const T*, size_t, int);
   TINKER_FCALL2(acc1, cu1, reduceSumOnDevice, dp_ans, a, nelem, queue);
}
 
template <class HT, size_t HN, class DPTR>
void reduceSum2OnDevice(HT (&dref)[HN], DPTR v, size_t nelem, int queue)
{
   // TINKER_FVOID2(cu, 1, acc, 1 reduceSum2OnDevice, ...);
   TINKER_FCALL2(acc1, cu1, reduceSum2OnDevice, dref, v, nelem, queue);
}
 
template <class T>
T dotProd(const T* a, const T* b, size_t nelem, int queue)
{
   // TINKER_FVOID1(acc1, cu0, T, dotProd, const T*, const T*, size_t, int);
   return TINKER_FCALL1(acc1, cu0, dotProd, a, b, nelem, queue);
}
 
template <class T>
void dotProd(T* ans, const T* a, const T* b, size_t nelem, int queue)
{
   // TINKER_FVOID2(acc1, cu1, dotProd, T*, const T*, const T*, size_t, int);
   TINKER_FCALL2(acc1, cu1, dotProd, ans, a, b, nelem, queue);
}
 
template <class T>
void scaleArray(T* dst, T scal, size_t nelem, int queue)
{
   // TINKER_FVOID2(acc1, cu1, scaleArray, T*, T, size_t, int);
   TINKER_FCALL2(acc1, cu1, scaleArray, dst, scal, nelem, queue);
}
}