GPUPreconditioner.h

Go to the documentation of this file.

//  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *  //
//                                                                                   //
//                       / /   / /    __    \ \  / /                                 //
//                      / /__ / /   / _ \    \ \/ /                                  //
//                     /  ___  /   | |/_/    / /\ \                                  //
//                    / /   / /    \_\      / /  \ \                                 //
//                                                                                   //
//                                                                                   //
//  Copyright (c) 2016, Jakub Benda, Charles University in Prague                    //
//                                                                                   //
// MIT License:                                                                      //
//                                                                                   //
//  Permission is hereby granted, free of charge, to any person obtaining a          //
// copy of this software and associated documentation files (the "Software"),        //
// to deal in the Software without restriction, including without limitation         //
// the rights to use, copy, modify, merge, publish, distribute, sublicense,          //
// and/or sell copies of the Software, and to permit persons to whom the             //
// Software is furnished to do so, subject to the following conditions:              //
//                                                                                   //
//  The above copyright notice and this permission notice shall be included          //
// in all copies or substantial portions of the Software.                            //
//                                                                                   //
//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS          //
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       //
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE       //
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, //
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF         //
// OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  //
//                                                                                   //
//  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *  //

#if (!defined(HEX_GPUPRECONDITIONER_H) && defined(WITH_OPENCL))
#define HEX_GPUPRECONDITIONER_H

// --------------------------------------------------------------------------------- //

#include <string>

// --------------------------------------------------------------------------------- //

#include <CL/cl.h>

// --------------------------------------------------------------------------------- //

#include "hex-arrays.h"
#include "hex-matrix.h"

// --------------------------------------------------------------------------------- //

#include "KPAPreconditioner.h"

// --------------------------------------------------------------------------------- //

#include "clarrays.h"

// --------------------------------------------------------------------------------- //

class GPUCGPreconditioner : public virtual KPACGPreconditioner
{
    public:
        
        // run-time selection mechanism
        preconditionerRunTimeSelectionDefinitions(GPUCGPreconditioner, "GPU")
        
        typedef struct sData
        {
            void hdflink (const char * file);
            
            bool hdfload (const char * file = nullptr);
            
            bool hdfsave (const char * file = nullptr) const;
            
            RowMatrix<Complex> invCl_invsqrtS, invsqrtS_Cl;
            
            cArray Dl;
            
            std::string filename;
        } Data;
        
        // default constructor needed by the RTS mechanism
        GPUCGPreconditioner () {}
        
        // constructor
        GPUCGPreconditioner
        (
            CommandLine  const & cmd,
            InputFile    const & inp,
            Parallel     const & par,
            AngularBasis const & ang,
            Bspline const & bspline_inner,
            Bspline const & bspline_full,
            Bspline const & bspline_panel_x,
            Bspline const & bspline_panel_y
        ) : CGPreconditioner
            (
                cmd, inp, par, ang,
                bspline_inner,
                bspline_full,
                bspline_panel_x,
                bspline_panel_y
            ),
            KPACGPreconditioner
            (
                cmd, inp, par, ang,
                bspline_inner,
                bspline_full,
                bspline_panel_x,
                bspline_panel_y
            )
        {
            // nothing more to do
        }
        
        // preconditioner description
        virtual std::string description () const;
        
        // reuse parent definitions
        using KPACGPreconditioner::rhs;
        using KPACGPreconditioner::update;
        
        // declare own definitions
        virtual void setup ();
        virtual void finish ();
        virtual void multiply (BlockArray<Complex> const & p, BlockArray<Complex> & q, MatrixSelection::Selection tri) const;
        virtual void precondition (BlockArray<Complex> const & r, BlockArray<Complex> & z) const;
        
    protected:
        
        // OpenCL environment
        cl_platform_id platform_;
        cl_device_id device_;
        cl_context context_;
        cl_command_queue queue_;
        cl_program program_;
        
        // size of a workgroup
        std::size_t Nlocal_;
        std::size_t blocksize_;
        
        // memory allocation flags
        cl_mem_flags smallDataFlags_;
        cl_mem_flags largeDataFlags_;
        
        // computational kernels
        cl_kernel mabt_;
        cl_kernel mml1_;
        cl_kernel mml2_dcpl_, mml2_cpld_;
        cl_kernel mml2_dcpl_offset_, mml2_cpld_offset_;
        cl_kernel axby_;
        cl_kernel norm_;
        cl_kernel spro_;
        cl_kernel krdv_;
        
        // device data connections
        mutable clArray<Complex> tmp_, tmA_;
        mutable clArray<Real> nrm_;
        clArrayView<Complex> t_inner_a_, t_inner_p_;
        clArrayView<Complex> S_inner_a_, D_inner_a_, Mm1_inner_a_, Mm2_inner_a_;
        clArrayView<Complex> S_inner_p_, D_inner_p_, Mm1_inner_p_, Mm2_inner_p_;
        std::vector<clArrayView<Complex>> M_L_inner_a_, M_mLm1_inner_a_;
        std::vector<clArrayView<Complex>> M_L_inner_p_, M_mLm1_inner_p_;
        std::vector<clArrayView<LU_int_t>> R_coupled_p_, R_coupled_i_;
        std::vector<clArrayView<Complex>> R_coupled_x_;
        
        cl_short nsrcseg_, ndstseg_;
};

// --------------------------------------------------------------------------------- //

#endif