VecOpMisc.h

#ifndef PRDC_VEC_OP_MISC_H
#define PRDC_VEC_OP_MISC_H
 
/*
* PSCF Package 
*
* Copyright 2016 - 2022, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include "types.h"
#include <pscf/cuda/DeviceArray.h>
#include <util/containers/DArray.h>
 
namespace Pscf {
namespace Prdc {
namespace Cuda {
namespace VecOp {
 
/*
* Miscellaneous element-wise vector operations performed on the GPU.
*
* Note: this file is included at the end of VecOp.h, so any file that 
* includes VecOp.h will also include this file.
*
* The functions defined in this file are wrappers for CUDA kernels that 
* perform the actual vector operations. The kernels themselves are only 
* intended to be called through their wrappers, so they are defined in 
* an anonymous namespace in VecOpMisc.cu.
*
* The functions defined in this file combine 2 or more element-wise 
* vector operations into a single kernel launch, which will perform the 
* operation faster than consecutively calling multiple of the functions 
* in VecOp.h. These functions are not intended to be comprehensive. 
* Rather, they are written and included as needed during the development 
* of other code.
*
* The names of these functions follow the same conventions as those in
* VecOp, using add, sub, mul, div, exp, eq, and combinations thereof to
* indicate the operation(s) being performed. V denotes a vector, S 
* denotes a scalar, and Vc denotes a vector that is multiplied by a 
* scalar coefficient and then used in another operation. For example, 
* addEqVc(a, b, c) performs a[i] += b[i] * c for all i. 
*
* Another set of functions defined in this file contain the word Pair, 
* indicating that these functions perform the same operation for a pair
* of output arrays. For example, eqVPair performs a1[i] = s[i] and 
* a2[i] = s[i] for all i. Performing these operations in pairs is 
* faster because the array s only needs to be loaded from global memory
* once. 
* 
* A third set of functions defined in this file contain the word "Many",
* indicating that an undefined number of vectors (>2) are involved in an 
* operation. For example, addVMany adds >2 vectors together by passing 
* an array of vectors, rather than a discrete set of vectors.
*/
 
// Functions that combine multiple VecOp operations
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
void addVcVc(DeviceArray<cudaReal>& a, 
             DeviceArray<cudaReal> const & b, cudaReal const c, 
             DeviceArray<cudaReal> const & d, cudaReal const e);
 
void addVcVcVc(DeviceArray<cudaReal>& a, 
               DeviceArray<cudaReal> const & b, cudaReal const c, 
               DeviceArray<cudaReal> const & d, cudaReal const e, 
               DeviceArray<cudaReal> const & f, cudaReal const g);
 
void addEqVc(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b, 
             cudaReal const c);
 
void subVVS(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b, 
            DeviceArray<cudaReal> const & c, cudaReal const d);
 
void divEqVc(DeviceArray<cudaComplex>& a, DeviceArray<cudaReal> const & b, 
             cudaReal const c);
 
void expVc(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b, 
           cudaReal const c);
 
 
// Pair functions
// ~~~~~~~~~~~~~~
 
void eqVPair(DeviceArray<cudaReal>& a1, DeviceArray<cudaReal>& a2, 
             DeviceArray<cudaReal> const & s);
 
void mulVVPair(DeviceArray<cudaReal>& a1, DeviceArray<cudaReal>& a2, 
               DeviceArray<cudaReal> const & b1, 
               DeviceArray<cudaReal> const & b2, 
               DeviceArray<cudaReal> const & s);
 
void mulEqVPair(DeviceArray<cudaReal>& a1, DeviceArray<cudaReal>& a2, 
                DeviceArray<cudaReal> const & s);
 
 
// Functions of "many" vectors
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
void addVMany(DeviceArray<cudaReal>& a, 
              DArray<DeviceArray<cudaReal> > const & vecs);
 
void addVMany(DeviceArray<cudaReal>& a, 
              DArray<DeviceArray<cudaReal> const *> const & vecs);
 
void mulVMany(DeviceArray<cudaReal>& a, 
              DArray<DeviceArray<cudaReal> > const & vecs);
 
void mulVMany(DeviceArray<cudaReal>& a, 
              DArray<DeviceArray<cudaReal> const *> const & vecs);
 
 
// Other useful functions
// ~~~~~~~~~~~~~~~~~~~~~~
 
void sqNormV(DeviceArray<cudaReal>& a, DeviceArray<cudaComplex> const & b);
 
void sqSqNormV(DeviceArray<cudaReal>& a, DeviceArray<cudaComplex> const & b);
 
} // namespace VecOp
} // namespace Cuda
} // namespace Prdc
} // namespace Pscf
#endif