Moved OpenclMatrix to new file

opm/simulators/linalg/bda/BlockedMatrix.hpp

@@ -22,13 +22,7 @@
 
 #if HAVE_FPGA
 #include <vector>
-namespace Opm
-{
-namespace Accelerator
-{
-    class Matrix;
-}
-}
+#include <opm/simulators/linalg/bda/Matrix.hpp>
 #endif
 
 

opm/simulators/linalg/bda/CPR.cpp

@@ -30,7 +30,9 @@
 #include <opm/simulators/linalg/PropertyTree.hpp>
 
 #include <opm/simulators/linalg/bda/BdaBridge.hpp>
+#include <opm/simulators/linalg/bda/BlockedMatrix.hpp>
 #include <opm/simulators/linalg/bda/CPR.hpp>
+#include <opm/simulators/linalg/bda/OpenclMatrix.hpp>
 
 
 namespace Opm

opm/simulators/linalg/bda/CPR.hpp

@@ -24,11 +24,11 @@
 
 #include <dune/istl/paamg/matrixhierarchy.hh>
 
-#include <opm/simulators/linalg/bda/BlockedMatrix.hpp>
+#include <opm/simulators/linalg/bda/opencl.hpp>
 #include <opm/simulators/linalg/bda/Matrix.hpp>
+#include <opm/simulators/linalg/bda/OpenclMatrix.hpp>
 #include <opm/simulators/linalg/bda/ILUReorder.hpp>
 
-#include <opm/simulators/linalg/bda/opencl.hpp>
 #include <opm/simulators/linalg/bda/openclKernels.hpp>
 #include <opm/simulators/linalg/bda/ChowPatelIlu.hpp>
 #include <opm/simulators/linalg/bda/openclSolverBackend.hpp>
@@ -41,6 +41,8 @@ namespace Accelerator
 template <unsigned int block_size>
 class openclSolverBackend;
 
+class BlockedMatrix;
+
 /// This class implements a Constrained Pressure Residual (CPR) preconditioner
 template <unsigned int block_size>
 class CPR

opm/simulators/linalg/bda/Matrix.cpp

@@ -31,29 +31,6 @@ namespace Opm
 namespace Accelerator
 {
 
-void OpenclMatrix::upload(cl::CommandQueue *queue, double *vals, int *cols, int *rows) {
-    std::vector<cl::Event> events(3);
-
-    cl_int err = queue->enqueueWriteBuffer(nnzValues, CL_FALSE, 0, sizeof(double) * block_size * block_size * nnzbs, vals, nullptr, &events[0]);
-    err |= queue->enqueueWriteBuffer(colIndices, CL_FALSE, 0, sizeof(int) * nnzbs, cols, nullptr, &events[1]);
-    err |= queue->enqueueWriteBuffer(rowPointers, CL_FALSE, 0, sizeof(int) * (Nb + 1), rows, nullptr, &events[2]);
-
-    cl::WaitForEvents(events);
-    events.clear();
-    if (err != CL_SUCCESS) {
-        // enqueueWriteBuffer is C and does not throw exceptions like C++ OpenCL
-        OPM_THROW(std::logic_error, "OpenclMatrix OpenCL enqueueWriteBuffer error");
-    }
-}
-
-void OpenclMatrix::upload(cl::CommandQueue *queue, Matrix *matrix) {
-    upload(queue, matrix->nnzValues.data(), matrix->colIndices.data(), matrix->rowPointers.data());
-}
-
-void OpenclMatrix::upload(cl::CommandQueue *queue, BlockedMatrix *matrix) {
-    upload(queue, matrix->nnzValues, matrix->colIndices, matrix->rowPointers);
-}
-
 /*Sort a row of matrix elements from a CSR-format.*/
 void sortRow(int *colIndices, double *data, int left, int right) {
     int l = left;

opm/simulators/linalg/bda/Matrix.hpp

@@ -22,45 +22,11 @@
 
 #include <vector>
 
-#include <opm/simulators/linalg/bda/opencl.hpp>
-#include <opm/simulators/linalg/bda/BlockedMatrix.hpp>
-
 namespace Opm
 {
 namespace Accelerator
 {
 
-class Matrix;
-
-/// This struct resembles a csr matrix, only doubles are supported
-/// The matrix data is stored in OpenCL Buffers
-class OpenclMatrix {
-public:
-
-    OpenclMatrix(cl::Context *context, int Nb_, int Mb_, int nnzbs_, unsigned int block_size_)
-    : Nb(Nb_),
-      Mb(Mb_),
-      nnzbs(nnzbs_),
-      block_size(block_size_)
-    {
-        nnzValues = cl::Buffer(*context, CL_MEM_READ_WRITE, sizeof(double) * block_size * block_size * nnzbs);
-        colIndices = cl::Buffer(*context, CL_MEM_READ_WRITE, sizeof(int) * nnzbs);
-        rowPointers = cl::Buffer(*context, CL_MEM_READ_WRITE, sizeof(int) * (Nb + 1));
-    }
-
-    void upload(cl::CommandQueue *queue, double *vals, int *cols, int *rows);
-    void upload(cl::CommandQueue *queue, Matrix *matrix);
-    void upload(cl::CommandQueue *queue, BlockedMatrix *matrix);
-
-    cl::Buffer nnzValues;
-    cl::Buffer colIndices;
-    cl::Buffer rowPointers;
-    int Nb, Mb;
-    int nnzbs;
-    unsigned int block_size;
-};
-
-
 /// This struct resembles a csr matrix, only doubles are supported
 /// The data is stored in contiguous memory, such that they can be copied to a device in one transfer.
 class Matrix {

opm/simulators/linalg/bda/OpenclMatrix.cpp

@@ -0,0 +1,58 @@
+/*
+  Copyright 2021 Equinor ASA
+
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <config.h>
+
+#include <opm/common/OpmLog/OpmLog.hpp>
+#include <opm/common/ErrorMacros.hpp>
+
+#include <opm/simulators/linalg/bda/OpenclMatrix.hpp>
+#include <opm/simulators/linalg/bda/BlockedMatrix.hpp>
+#include <opm/simulators/linalg/bda/Matrix.hpp>
+
+namespace Opm
+{
+namespace Accelerator
+{
+
+void OpenclMatrix::upload(cl::CommandQueue *queue, double *vals, int *cols, int *rows) {
+    std::vector<cl::Event> events(3);
+
+    cl_int err = queue->enqueueWriteBuffer(nnzValues, CL_FALSE, 0, sizeof(double) * block_size * block_size * nnzbs, vals, nullptr, &events[0]);
+    err |= queue->enqueueWriteBuffer(colIndices, CL_FALSE, 0, sizeof(int) * nnzbs, cols, nullptr, &events[1]);
+    err |= queue->enqueueWriteBuffer(rowPointers, CL_FALSE, 0, sizeof(int) * (Nb + 1), rows, nullptr, &events[2]);
+
+    cl::WaitForEvents(events);
+    events.clear();
+    if (err != CL_SUCCESS) {
+        // enqueueWriteBuffer is C and does not throw exceptions like C++ OpenCL
+        OPM_THROW(std::logic_error, "OpenclMatrix OpenCL enqueueWriteBuffer error");
+    }
+}
+
+void OpenclMatrix::upload(cl::CommandQueue *queue, Matrix *matrix) {
+    upload(queue, matrix->nnzValues.data(), matrix->colIndices.data(), matrix->rowPointers.data());
+}
+
+void OpenclMatrix::upload(cl::CommandQueue *queue, BlockedMatrix *matrix) {
+    upload(queue, matrix->nnzValues, matrix->colIndices, matrix->rowPointers);
+}
+
+} // namespace Accelerator
+} // namespace Opm

opm/simulators/linalg/bda/OpenclMatrix.hpp

@@ -0,0 +1,66 @@
+/*
+  Copyright 2021 Equinor ASA
+
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef OPM_OPENCLMATRIX_HEADER_INCLUDED
+#define OPM_OPENCLMATRIX_HEADER_INCLUDED
+
+#include <vector>
+
+#include <opm/simulators/linalg/bda/opencl.hpp>
+
+namespace Opm
+{
+namespace Accelerator
+{
+
+class Matrix;
+class BlockedMatrix;
+
+/// This struct resembles a csr matrix, only doubles are supported
+/// The matrix data is stored in OpenCL Buffers
+class OpenclMatrix {
+public:
+
+    OpenclMatrix(cl::Context *context, int Nb_, int Mb_, int nnzbs_, unsigned int block_size_)
+    : Nb(Nb_),
+      Mb(Mb_),
+      nnzbs(nnzbs_),
+      block_size(block_size_)
+    {
+        nnzValues = cl::Buffer(*context, CL_MEM_READ_WRITE, sizeof(double) * block_size * block_size * nnzbs);
+        colIndices = cl::Buffer(*context, CL_MEM_READ_WRITE, sizeof(int) * nnzbs);
+        rowPointers = cl::Buffer(*context, CL_MEM_READ_WRITE, sizeof(int) * (Nb + 1));
+    }
+
+    void upload(cl::CommandQueue *queue, double *vals, int *cols, int *rows);
+    void upload(cl::CommandQueue *queue, Matrix *matrix);
+    void upload(cl::CommandQueue *queue, BlockedMatrix *matrix);
+
+    cl::Buffer nnzValues;
+    cl::Buffer colIndices;
+    cl::Buffer rowPointers;
+    int Nb, Mb;
+    int nnzbs;
+    unsigned int block_size;
+};
+
+} // namespace Accelerator
+} // namespace Opm
+
+#endif // OPM_OPENCLMATRIX_HEADER_INCLUDED