[Code] Add utility for csr build/extract logic

Author: EgorOrachyov

README.md

@@ -59,13 +59,13 @@ prototyping algorithms on a local computer for later running on a powerful serve
 
 ## Installation
 
-If you running OS **Ubuntu 20.04** or higher you can download the official
-PyPI **pycubool** python package, which includes compiled library source
+If you are running OS **Ubuntu 20.04** or higher you can download the official
+PyPI **pycubool** python package, which includes compiled library source code
 with Cuda and Sequential computations support. Installation process 
 requires only `python3` to be installed on your machine. Python can be installed 
 as follows [link](https://phoenixnap.com/kb/how-to-install-python-3-ubuntu).
 
-If all requirements satisfied, run the following command to install PyPI package:
+If all requirements are satisfied, run the following command to install PyPI package:
 ```shell script
 $ python3 -m pip install -i https://test.pypi.org/simple/ pycubool
 ``` 
@@ -274,7 +274,7 @@ cuBool
 │   │   └── sequential - fallback cpu backend
 │   ├── utils - testing utilities
 │   └── tests - gtest-based unit-tests collection
-├── python - pycubool related source
+├── python - pycubool related sources
 │   ├── pycubool - cubool library wrapper for python (similar to pygraphblas)
 │   ├── tests - regression tests for python wrapper
 │   └── data - generate data for pycubool regression tests

cubool/CMakeLists.txt

@@ -26,6 +26,8 @@ set(CUBOOL_SOURCES
     sources/io/logger.hpp
     sources/utils/exclusive_scan.hpp
     sources/utils/timer.hpp
+    sources/utils/csr_utils.cpp
+    sources/utils/csr_utils.hpp
         )
 
 set(CUBOOL_C_API_SOURCES
@@ -72,8 +74,8 @@ if (CUBOOL_WITH_CUDA)
         sources/cuda/instance.cpp
         sources/cuda/matrix_csr.hpp
         sources/cuda/matrix_csr.cu
-        sources/cuda/matrix_csr_build.cpp
-        sources/cuda/matrix_csr_extract.cpp
+        sources/cuda/matrix_csr_build.cu
+        sources/cuda/matrix_csr_extract.cu
         sources/cuda/matrix_csr_ewiseadd.cu
         sources/cuda/matrix_csr_kronecker.cu
         sources/cuda/matrix_csr_multiply.cu

cubool/sources/cuda/matrix_csr.hpp

@@ -46,8 +46,7 @@ namespace cubool {
         void setElement(index i, index j) override;
         void build(const index *rows, const index *cols, size_t nvals, bool isSorted, bool noDuplicates) override;
         void extract(index* rows, index* cols, size_t &nvals) override;
-        void extractSubMatrix(const MatrixBase &otherBase, index i, index j, index nrows, index ncols,
-                              bool checkTime) override;
+        void extractSubMatrix(const MatrixBase &otherBase, index i, index j, index nrows, index ncols, bool checkTime) override;
 
         void clone(const MatrixBase &other) override;
         void transpose(const MatrixBase &other, bool checkTime) override;

cubool/sources/cuda/matrix_csr_build.cu

@@ -0,0 +1,46 @@
+/**********************************************************************************/
+/* MIT License                                                                    */
+/*                                                                                */
+/* Copyright (c) 2020, 2021 JetBrains-Research                                    */
+/*                                                                                */
+/* 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.                                                                      */
+/**********************************************************************************/
+
+#include <cuda/matrix_csr.hpp>
+#include <utils/csr_utils.hpp>
+
+namespace cubool {
+
+    void MatrixCsr::build(const index *rows, const index *cols, size_t nvals, bool isSorted, bool noDuplicates) {
+        if (nvals == 0) {
+            mMatrixImpl.zero_dim();  // no content, empty matrix
+            return;
+        }
+
+        // Build csr structure and store on cpu side
+        std::vector<index> rowOffsets;
+        std::vector<index> colIndices;
+
+        CsrUtils::buildFromData(getNrows(), getNcols(), rows, cols, nvals, rowOffsets, colIndices, isSorted, noDuplicates);
+
+        // Move actual data to the matrix implementation
+        this->transferToDevice(rowOffsets, colIndices);
+    }
+
+}

cubool/sources/cuda/matrix_csr_extract.cpp renamed to cubool/sources/cuda/matrix_csr_extract.cu

@@ -23,7 +23,7 @@
 /**********************************************************************************/
 
 #include <cuda/matrix_csr.hpp>
-#include <vector>
+#include <utils/csr_utils.hpp>
 
 namespace cubool {
 
@@ -40,16 +40,7 @@ namespace cubool {
 
             this->transferFromDevice(rowOffsets, colIndices);
 
-            // Iterate over csr formatted data
-            size_t idx = 0;
-            for (index i = 0; i < getNrows(); i++) {
-                for (index j = rowOffsets[i]; j < rowOffsets[i + 1]; j++) {
-                    rows[idx] = i;
-                    cols[idx] = colIndices[j];
-
-                    idx += 1;
-                }
-            }
+            CsrUtils::extractData(getNrows(), getNcols(), rows, cols, nvals, rowOffsets, colIndices);
         }
     }
 

cubool/sources/sequential/sq_matrix.cpp

@@ -29,9 +29,8 @@
 #include <sequential/sq_ewiseadd.hpp>
 #include <sequential/sq_spgemm.hpp>
 #include <sequential/sq_reduce.hpp>
-#include <utils/exclusive_scan.hpp>
+#include <utils/csr_utils.hpp>
 #include <core/error.hpp>
-#include <algorithm>
 #include <cassert>
 
 namespace cubool {
@@ -53,110 +52,20 @@ namespace cubool {
         auto ncols = mData.ncols;
 
         mData.rowOffsets.clear();
-        mData.rowOffsets.resize(nrows + 1, 0);
         mData.colIndices.clear();
-        mData.colIndices.resize(nvals);
 
-        if (nvals == 0)
-            return;
-
-        assert(rows);
-        assert(cols);
-
-        for (size_t k = 0; k < nvals; k++) {
-            auto i = rows[k];
-            auto j = cols[k];
-
-            CHECK_RAISE_ERROR(i < nrows, InvalidArgument, "Index out of matrix bound");
-            CHECK_RAISE_ERROR(j < ncols, InvalidArgument, "Index out of matrix bound");
-
-            mData.rowOffsets[i]++;
-        }
-
-        exclusive_scan(mData.rowOffsets.begin(), mData.rowOffsets.end(), 0);
-
-        std::vector<size_t> writeOffset(nrows, 0);
-        for (size_t k = 0; k < nvals; k++) {
-            auto i = rows[k];
-            auto j = cols[k];
-
-            mData.colIndices[mData.rowOffsets[i] + writeOffset[i]] = j;
-            writeOffset[i] += 1;
-        }
-
-        if (!isSorted) {
-            for (size_t i = 0; i < getNrows(); i++) {
-                auto begin = mData.rowOffsets[i];
-                auto end = mData.rowOffsets[i + 1];
-
-                // Sort col values within row
-                std::sort(mData.colIndices.begin() + begin, mData.colIndices.begin() + end, [](const index& a, const index& b) {
-                    return a < b;
-                });
-            }
-        }
-
-        if (!noDuplicates) {
-            size_t unique = 0;
-            for (size_t i = 0; i < getNrows(); i++) {
-                index prev = std::numeric_limits<index>::max();
-
-                for (size_t k = mData.rowOffsets[i]; k < mData.rowOffsets[i + 1]; k++) {
-                    if (prev != mData.colIndices[k]) {
-                        unique += 1;
-                    }
-
-                    prev = mData.colIndices[k];
-                }
-            }
-
-            std::vector<index> rowOffsetsReduced;
-            rowOffsetsReduced.resize(getNrows() + 1, 0);
-
-            std::vector<index> colIndicesReduced;
-            colIndicesReduced.reserve(unique);
-
-            for (size_t i = 0; i < getNrows(); i++) {
-                index prev = std::numeric_limits<index>::max();
-
-                for (size_t k = mData.rowOffsets[i]; k < mData.rowOffsets[i + 1]; k++) {
-                    if (prev != mData.colIndices[k]) {
-                        rowOffsetsReduced[i] += 1;
-                        colIndicesReduced.push_back(mData.colIndices[k]);
-                    }
-
-                    prev = mData.colIndices[k];
-                }
-            }
-
-            // Exclusive scan to eval rows offsets
-            exclusive_scan(rowOffsetsReduced.begin(), rowOffsetsReduced.end(), 0);
-
-            // Now result in respective place
-            std::swap(mData.rowOffsets, rowOffsetsReduced);
-            std::swap(mData.colIndices, colIndicesReduced);
-        }
+        // Call utility to build csr row offsets and column indices and store in mData vectors
+        CsrUtils::buildFromData(nrows, ncols, rows, cols, nvals, mData.rowOffsets, mData.colIndices, isSorted, noDuplicates);
 
         mData.nvals = mData.colIndices.size();
     }
 
     void SqMatrix::extract(index *rows, index *cols, size_t &nvals) {
         assert(nvals >= getNvals());
-
         nvals = getNvals();
 
         if (nvals > 0) {
-            assert(rows);
-            assert(cols);
-
-            size_t id = 0;
-            for (index i = 0; i < getNrows(); i++) {
-                for (index k = mData.rowOffsets[i]; k < mData.rowOffsets[i + 1]; k++) {
-                    rows[id] = i;
-                    cols[id] = mData.colIndices[k];
-                    id += 1;
-                }
-            }
+            CsrUtils::extractData(getNrows(), getNcols(), rows, cols, nvals, mData.rowOffsets, mData.colIndices);
         }
     }
 

cubool/sources/cuda/matrix_csr_build.cpp renamed to cubool/sources/utils/csr_utils.cpp

@@ -22,51 +22,53 @@
 /* SOFTWARE.                                                                      */
 /**********************************************************************************/
 
-#include <cuda/matrix_csr.hpp>
+#include <utils/csr_utils.hpp>
 #include <utils/exclusive_scan.hpp>
-#include <vector>
+#include <core/error.hpp>
 #include <algorithm>
+#include <cassert>
 
 namespace cubool {
 
-    void MatrixCsr::build(const index *rows, const index *cols, size_t nvals, bool isSorted, bool noDuplicates) {
-        if (nvals == 0) {
-            mMatrixImpl.zero_dim();  // no content, empty matrix
-            return;
-        }
-
-        std::vector<index> rowOffsets;
-        rowOffsets.resize(getNrows() + 1, 0);
+    void CsrUtils::buildFromData(size_t nrows, size_t ncols,
+                                 const index *rows, const index *cols, size_t nvals,
+                                 std::vector<index> &rowOffsets, std::vector<index> &colIndices,
+                                 bool isSorted, bool noDuplicates) {
 
-        std::vector<index> colIndices;
+        rowOffsets.resize(nrows + 1, 0);
         colIndices.resize(nvals);
 
-        // Compute nnz per row
-        for (size_t idx = 0; idx < nvals; idx++) {
-            index i = rows[idx];
-            index j = cols[idx];
+        std::fill(rowOffsets.begin(), rowOffsets.end(), 0);
 
-            CHECK_RAISE_ERROR(i < getNrows() && j < getNcols(), InvalidArgument, "Out of matrix bounds value");
+        if (nvals == 0)
+            return;
 
-            rowOffsets[i] += 1;
-        }
+        assert(rows);
+        assert(cols);
 
-        // Exclusive scan to eval rows offsets
-        ::cubool::exclusive_scan(rowOffsets.begin(), rowOffsets.end(), 0);
+        for (size_t k = 0; k < nvals; k++) {
+            auto i = rows[k];
+            auto j = cols[k];
 
-        // Write offsets for cols
-        std::vector<size_t> writeOffsets(getNrows(), 0);
+            CHECK_RAISE_ERROR(i < nrows, InvalidArgument, "Index out of matrix bounds");
+            CHECK_RAISE_ERROR(j < ncols, InvalidArgument, "Index out of matrix bounds");
 
-        for (size_t idx = 0; idx < nvals; idx++) {
-            index i = rows[idx];
-            index j = cols[idx];
+            rowOffsets[i]++;
+        }
 
-            colIndices[rowOffsets[i] + writeOffsets[i]] = j;
-            writeOffsets[i] += 1;
+        exclusive_scan(rowOffsets.begin(), rowOffsets.end(), 0);
+
+        std::vector<size_t> writeOffset(nrows, 0);
+        for (size_t k = 0; k < nvals; k++) {
+            auto i = rows[k];
+            auto j = cols[k];
+
+            colIndices[rowOffsets[i] + writeOffset[i]] = j;
+            writeOffset[i] += 1;
         }
 
         if (!isSorted) {
-            for (size_t i = 0; i < getNrows(); i++) {
+            for (size_t i = 0; i < nrows; i++) {
                 auto begin = rowOffsets[i];
                 auto end = rowOffsets[i + 1];
 
@@ -77,10 +79,9 @@ namespace cubool {
             }
         }
 
-        // Reduce duplicated values
         if (!noDuplicates) {
             size_t unique = 0;
-            for (size_t i = 0; i < getNrows(); i++) {
+            for (size_t i = 0; i < nrows; i++) {
                 index prev = std::numeric_limits<index>::max();
 
                 for (size_t k = rowOffsets[i]; k < rowOffsets[i + 1]; k++) {
@@ -93,12 +94,12 @@ namespace cubool {
             }
 
             std::vector<index> rowOffsetsReduced;
-            rowOffsetsReduced.resize(getNrows() + 1, 0);
+            rowOffsetsReduced.resize(nrows + 1, 0);
 
             std::vector<index> colIndicesReduced;
             colIndicesReduced.reserve(unique);
 
-            for (size_t i = 0; i < getNrows(); i++) {
+            for (size_t i = 0; i < nrows; i++) {
                 index prev = std::numeric_limits<index>::max();
 
                 for (size_t k = rowOffsets[i]; k < rowOffsets[i + 1]; k++) {
@@ -112,15 +113,28 @@ namespace cubool {
             }
 
             // Exclusive scan to eval rows offsets
-            ::cubool::exclusive_scan(rowOffsetsReduced.begin(), rowOffsetsReduced.end(), 0);
+            exclusive_scan(rowOffsetsReduced.begin(), rowOffsetsReduced.end(), 0);
 
             // Now result in respective place
             std::swap(rowOffsets, rowOffsetsReduced);
             std::swap(colIndices, colIndicesReduced);
         }
+    }
 
-        // Move actual data to the matrix implementation
-        this->transferToDevice(rowOffsets, colIndices);
+    void CsrUtils::extractData(size_t nrows, size_t ncols,
+                               index *rows, index *cols, size_t nvals,
+                               const std::vector<index> &rowOffsets, const std::vector<index> &colIndices) {
+        assert(rows);
+        assert(cols);
+
+        size_t id = 0;
+        for (index i = 0; i < nrows; i++) {
+            for (index k = rowOffsets[i]; k < rowOffsets[i + 1]; k++) {
+                rows[id] = i;
+                cols[id] = colIndices[k];
+                id += 1;
+            }
+        }
     }
 
 }