Introduced abstractions for bool csr matrices

Author: nikitavlaev

src/include/clSPARSE-1x.h

@@ -89,6 +89,39 @@ typedef struct clsparseCsrMatrix_
     void* meta;
 } clsparseCsrMatrix;
 
+/*! \brief Structure to encapsulate boolean sparse matrix data encoded in CSR
+ * form to clSPARSE API
+ */
+typedef struct clsparseBoolCsrMatrix_
+{
+    /** @name CSR matrix data */
+    /**@{*/
+    clsparseIdx_t num_rows;  /*!< Number of rows this matrix has if viewed as dense */
+    clsparseIdx_t num_cols;  /*!< Number of columns this matrix has if viewed as dense */
+    clsparseIdx_t num_nonzeros;  /*!< Number of values in matrix that are non-zero */
+    /**@}*/
+
+    /** @name OpenCL state */
+    /**@{*/
+    cl_mem col_indices;  /*!< column index for corresponding value of size num_nonzeros */
+    cl_mem row_pointer;  /*!< Invariant: row_pointer[i+1]-row_pointer[i] = number of values in row i */
+    /**@}*/
+
+    /** @name Buffer offsets */
+    /**@{*/
+    /*! Given that cl_mem objects are opaque without pointer arithmetic, these offsets are added to
+     * the cl_mem locations on device to define beginning of the data in the cl_mem buffers
+     */
+    clsparseIdx_t off_col_indices;
+    clsparseIdx_t off_row_pointer;
+    /**@}*/
+
+    /*! Pointer to a private structure that contains meta-information the library keeps on a 
+    csr-encoded sparse matrix
+    */
+    void* meta;
+} clsparseBoolCsrMatrix;
+
 /*! \brief Structure to encapsulate sparse matrix data encoded in COO
  * form to clSPARSE API
  * \note The indices stored are 0-based

src/include/clSPARSE-2x.h

@@ -68,6 +68,30 @@ typedef struct clsparseCsrMatrix_
     void* meta;
 } clsparseCsrMatrix;
 
+/*! \brief Structure to encapsulate sparse bool matrix data encoded in CSR
+* form to clSPARSE API
+*/
+typedef struct clsparseBoolCsrMatrix_
+{
+    /** @name CSR matrix data */
+    /**@{*/
+    clsparseIdx_t num_rows;  /*!< Number of rows this matrix has if viewed as dense */
+    clsparseIdx_t num_cols;  /*!< Number of columns this matrix has if viewed as dense */
+    clsparseIdx_t num_nonzeros;  /*!< Number of values in matrix that are non-zero */
+    /**@}*/
+
+    /** @name OpenCL state */
+    /**@{*/
+    void* col_indices;  /*!< column index for corresponding value of size num_nonzeros */
+    void* row_pointer;  /*!< Invariant: row_pointer[i+1]-row_pointer[i] = number of values in row i */
+    /**@}*/
+
+    /*! Pointer to a private structure that contains meta-information the library keeps on a
+    csr-encoded sparse matrix
+    */
+    void* meta;
+} clsparseBoolCsrMatrix;
+
 /*! \brief Structure to encapsulate sparse matrix data encoded in COO
 * form to clSPARSE API
 * \note The indices stored are 0-based

src/include/clSPARSE.h

@@ -200,6 +200,19 @@ extern "C" {
     CLSPARSE_EXPORT clsparseStatus
         clsparseInitCsrMatrix( clsparseCsrMatrix* csrMatx );
 
+    /*!
+    * \brief Initialize a BOOL sparse matrix CSR structure to be used in the clsparse library
+    * \note It is users responsibility to allocate OpenCL device memory
+    *
+    * \param[out] csrMatx  Sparse BOOL CSR matrix structure to be initialized
+    *
+    * \returns \b clsparseSuccess
+    *
+    * \ingroup INIT
+    */
+    CLSPARSE_EXPORT clsparseStatus
+        clsparseInitBoolCsrMatrix( clsparseBoolCsrMatrix* csrMatx );
+
     /*!
     * \brief Initialize a dense matrix structure to be used in the clsparse library
     * \note It is users responsibility to allocate OpenCL device memory
@@ -590,6 +603,31 @@ extern "C" {
     CLSPARSE_EXPORT clsparseStatus
         clsparseSCsrMatrixfromFile( clsparseCsrMatrix* csrMatx, const char* filePath, clsparseControl control, cl_bool read_explicit_zeroes );
 
+    /*!
+     * \brief Read BOOL sparse matrix data from file in CSR format
+     * \details This function reads the contents of the sparse matrix file into clsparseBoolCsrMatrix data structure.
+     * The data structure represents the contents of the sparse matrix data in OpenCL device memory.
+     * This function sorts the values read (on host) by row, then column before copying them into
+     * device memory
+     * \param[out] csrMatx  The BOOL CSR sparse structure that represents the matrix in device memory
+     * \param[in] filePath  A path in the file-system to the sparse matrix file
+     * \param[in] control A valid clsparseControl created with clsparseCreateControl
+     * \param[in] read_explicit_zeroes If the file contains values explicitly declared zero, this controls
+     * whether they are stored in the CSR
+     *
+     * \note The number of non-zeroes actually read from the file may be less than the number of
+     * non-zeroes reported from the file header. Symmetrix matrices may store up to twice as many non-zero
+     * values compared to the number of values in the file. Explicitly declared zeroes may be stored
+     * or not depending on the input \p read_explicit_zeroes.
+     * \note The OpenCL device memory must be allocated before the call to this function.
+     * \post The sparse data is sorted first by row, then by column.
+     * \returns \b clsparseSuccess
+     *
+     * \ingroup FILE
+     */
+    CLSPARSE_EXPORT clsparseStatus
+        clsparseSBoolCsrMatrixfromFile( clsparseBoolCsrMatrix* csrMatx, const char* filePath, clsparseControl control, cl_bool read_explicit_zeroes );
+
     /*!
      * \brief Read sparse matrix data from file in double precision CSR format
      * \details This function reads the contents of the sparse matrix file into clsparseCsrMatrix data structure.
@@ -664,6 +702,44 @@ extern "C" {
     CLSPARSE_EXPORT clsparseStatus
         clsparseCsrMetaDelete( clsparseCsrMatrix* csrMatx );
 
+    /*!
+     * \brief Calculate the amount of device memory required to hold meta-data for csr-adaptive SpM-dV algorithm
+     * \details CSR-adaptive is a high performance sparse matrix times dense vector algorithm.  It requires a pre-processing
+     * step to calculate meta-data on the sparse matrix.  This meta-data is stored alongside and carried along
+     * with the other matrix data.
+     * \param[in,out] csrMatx  The BOOL CSR sparse structure that represents the matrix in device memory
+     * \param[in] control A valid clsparseControl created with clsparseCreateControl
+     *
+     * \ingroup FILE
+    */
+    CLSPARSE_EXPORT clsparseMetaSizeResult
+        clsparseBoolCsrMetaSize( clsparseBoolCsrMatrix* csrMatx, clsparseControl control );
+
+    /*!
+     * \brief Allocate memory and calculate the meta-data for csr-adaptive SpM-dV algorithm
+     * \details CSR-adaptive is a high performance sparse matrix times dense vector algorithm.  It requires a pre-processing
+     * step to calculate meta-data on the sparse matrix.  This meta-data is stored alongside and carried along
+     * with the other matrix data.  This function allocates memory for the meta-data and initializes it with proper values.
+     * It is important to remember to deallocate the meta memory with clsparseCsrMetaDelete
+     * \param[in,out] csrMatx  The BOOL CSR sparse structure that represents the matrix in device memory
+     * \param[in] control  A valid clsparseControl created with clsparseCreateControl
+     * \note This function assumes that the memory for rowBlocks has already been allocated by client program
+     *
+     * \ingroup FILE
+     */
+    CLSPARSE_EXPORT clsparseStatus
+        clsparseBoolCsrMetaCreate( clsparseBoolCsrMatrix* csrMatx, clsparseControl control );
+
+    /*!
+    * \brief Delete meta data associated with a CSR encoded matrix
+    * \details Meta data for a sparse matrix may occupy device memory, and this informs the library to release it
+    * \param[in,out] csrMatx  The BOOL CSR sparse structure that represents the matrix in device memory
+    *
+    * \ingroup FILE
+    */
+    CLSPARSE_EXPORT clsparseStatus
+        clsparseBoolCsrMetaDelete( clsparseBoolCsrMatrix* csrMatx );
+
     /**@}*/
 
     /*!
@@ -1209,6 +1285,41 @@ extern "C" {
                           const clsparseControl control );
     /**@}*/
 
+    /*!
+     * \brief BOOL Single Precision CSR Sparse Matrix times Sparse Matrix
+     * \details \f$ C \leftarrow A \ast B \f$
+     * \param[in] sparseMatA Input CSR sparse matrix
+     * \param[in] sparseMatB Input CSR sparse matrix
+     * \param[out] sparseMatC Output CSR sparse matrix
+     * \param[in] control A valid clsparseControl created with clsparseCreateControl
+     * \pre The input sparse matrices data must first be sorted by rows, then by columns
+     * \ingroup BLAS-3
+     */
+   CLSPARSE_EXPORT clsparseStatus
+      clsparseBoolScsrSpGemm( const clsparseBoolCsrMatrix* sparseMatA,
+                              const clsparseBoolCsrMatrix* sparseMatB,
+                                    clsparseBoolCsrMatrix* sparseMatC,
+                              const clsparseControl control );
+    /**@}*/
+
+    /*!
+     * \brief BOOL Single Precision CSR Sparse Matrix PLUS Sparse Matrix
+     * \details \f$ C \leftarrow A \plus B \f$
+     * \param[in] sparseMatA Input CSR sparse matrix
+     * \param[in] sparseMatB Input CSR sparse matrix
+     * \param[out] sparseMatC Output CSR sparse matrix
+     * \param[in] control A valid clsparseControl created with clsparseCreateControl
+     * \pre The input sparse matrices data must first be sorted by rows, then by columns
+     * \ingroup BLAS-3
+     */
+   CLSPARSE_EXPORT clsparseStatus
+      clsparseBoolScsrElemAdd( const clsparseBoolCsrMatrix* sparseMatA,
+                               const clsparseBoolCsrMatrix* sparseMatB,
+                                     clsparseBoolCsrMatrix* sparseMatC,
+                               const clsparseControl control );
+    /**@}*/
+
+
     /*!
      * \defgroup CONVERT Matrix conversion routines
      *

src/library/CMakeLists.txt

@@ -133,7 +133,6 @@ set( clSPARSE.source.blas3
   blas3/clsparse-csrmm.cpp
   blas3/clsparse-spm-spm.cpp
   blas3/clsparse-bool-spm-spm.cpp
-  blas3/clsparse-bool-elem-add.cpp
 )
 
 set( clSPARSE.source.solvers

src/library/clsparse-init.cpp

@@ -97,6 +97,15 @@ clsparseInitCsrMatrix( clsparseCsrMatrix* csrMatx )
     return clsparseSuccess;
 };
 
+clsparseStatus
+clsparseInitBoolCsrMatrix( clsparseBoolCsrMatrix* csrMatx )
+{
+    clsparseBoolCsrMatrixPrivate* pCsrMatx = static_cast<clsparseBoolCsrMatrixPrivate*>( csrMatx );
+    pCsrMatx->clear( );
+
+    return clsparseSuccess;
+};
+
 clsparseStatus
 cldenseInitMatrix( cldenseMatrix* denseMatx )
 {

src/library/include/clSPARSE-1x.hpp

@@ -233,6 +233,33 @@ class clsparseCsrMatrixPrivate: public clsparseCsrMatrix
     }
 };
 
+class clsparseBoolCsrMatrixPrivate: public clsparseBoolCsrMatrix
+{
+public:
+    void clear( )
+    {
+        num_rows = num_cols = num_nonzeros = 0;
+        col_indices = row_pointer = nullptr;
+        off_col_indices = off_row_pointer = 0;
+        meta = nullptr;
+    }
+
+    clsparseIdx_t nnz_per_row() const
+    {
+        return num_nonzeros / num_rows;
+    }
+
+    clsparseIdx_t colIndOffset() const
+    {
+        return off_col_indices;
+    }
+
+    clsparseIdx_t rowOffOffset() const
+    {
+        return off_row_pointer;
+    }
+};
+
 class clsparseCooMatrixPrivate: public clsparseCooMatrix
 {
 public:
@@ -286,6 +313,7 @@ class cldenseMatrixPrivate: public cldenseMatrix
 static_assert( std::is_standard_layout< clsparseScalarPrivate >::value, "The C++ wrapper classes have to have same memory layout as the C class they inherit from" );
 static_assert( std::is_standard_layout< cldenseVectorPrivate >::value, "The C++ wrapper classes have to have same memory layout as the C class they inherit from" );
 static_assert( std::is_standard_layout< clsparseCsrMatrixPrivate >::value, "The C++ wrapper classes have to have same memory layout as the C class they inherit from" );
+static_assert( std::is_standard_layout< clsparseBoolCsrMatrixPrivate >::value, "The C++ wrapper classes have to have same memory layout as the C class they inherit from" );
 static_assert( std::is_standard_layout< clsparseCooMatrixPrivate >::value, "The C++ wrapper classes have to have same memory layout as the C class they inherit from" );
 static_assert( std::is_standard_layout< cldenseMatrixPrivate>::value, "The C++ wrapper classes have to have same memory layout as the C class they inherit from" );
 

src/library/include/clSPARSE-2x.hpp

@@ -208,6 +208,37 @@ class clsparseCsrMatrixPrivate: public clsparseCsrMatrix
     }
 };
 
+class clsparseBoolCsrMatrixPrivate: public clsparseBoolCsrMatrix
+{
+public:
+    void clear( )
+    {
+        num_rows = num_cols = num_nonzeros = 0;
+        col_indices = row_pointer = rowBlocks = nullptr;
+        rowBlockSize = 0;
+    }
+
+    clsparseIdx_t nnz_per_row() const
+    {
+        return num_nonzeros / num_rows;
+    }
+
+    cl_ulong colIndOffset () const
+    {
+        return 0;
+    }
+
+    cl_ulong rowOffOffset () const
+    {
+        return 0;
+    }
+
+    cl_ulong rowBlocksOffset( ) const
+    {
+        return 0;
+    }
+};
+
 class clsparseCooMatrixPrivate: public clsparseCooMatrix
 {
 public:
@@ -253,6 +284,7 @@ class cldenseMatrixPrivate: public cldenseMatrix
 static_assert( std::is_standard_layout< clsparseScalarPrivate >::value, "The C++ wrapper classes have to have same memory layout as the C class they inherit from" );
 static_assert( std::is_standard_layout< cldenseVectorPrivate >::value, "The C++ wrapper classes have to have same memory layout as the C class they inherit from" );
 static_assert( std::is_standard_layout< clsparseCsrMatrixPrivate >::value, "The C++ wrapper classes have to have same memory layout as the C class they inherit from" );
+static_assert( std::is_standard_layout< clsparseBoolCsrMatrixPrivate >::value, "The C++ wrapper classes have to have same memory layout as the C class they inherit from" );
 static_assert( std::is_standard_layout< clsparseCooMatrixPrivate >::value, "The C++ wrapper classes have to have same memory layout as the C class they inherit from" );
 static_assert( std::is_standard_layout< cldenseMatrixPrivate >::value, "The C++ wrapper classes have to have same memory layout as the C class they inherit from" );