Merge pull request #442 from DrTimothyAldenDavis/v10.3.1_branch

DrTimothyAldenDavis · web-flow · commit 1fd54756ca57 · 2026-02-05T17:43:01.000-06:00
GraphBLAS 10.3.1
diff --git a/Doc/ChangeLog b/Doc/ChangeLog
@@ -1,3 +1,10 @@
+Jan 21, 2026, version 10.3.1
+
+    * (67) bug fix:  incorrect JIT kernel constructed for R=masker(C,M,Z)
+        when R is hypersparse.  Found by Roi Lipman, FalkorDB.
+    * (66) bug fix:  GB_bitonic did not compile with the MS cl compiler.
+        Found by Erik Welch, NVIDIA.
+
 Dec 3, 2025, version 10.3.0
 
     * GrB_extract: performance improvement for C=A(I,J) when A is very large
diff --git a/Doc/GraphBLAS_UserGuide.pdf b/Doc/GraphBLAS_UserGuide.pdf
diff --git a/Doc/GraphBLAS_version.tex b/Doc/GraphBLAS_version.tex
@@ -1,5 +1,5 @@
 % version of SuiteSparse:GraphBLAS
 \date{VERSION
-10.3.0,
-Dec 3, 2025}
+10.3.1,
+Jan 21, 2026}
 
diff --git a/Doc/UserGuide/GrB_release.tex b/Doc/UserGuide/GrB_release.tex
@@ -5,6 +5,15 @@ \section{Release Notes}
 
 \begin{itemize}
 
+\item Jan 21, 2026: version 10.3.1
+
+    \begin{itemize}
+    \item (67) bug fix:  incorrect JIT kernel constructed for R=masker(C,M,Z)
+        when R is hypersparse.  Found by Roi Lipman, FalkorDB.
+    \item (66) bug fix:  \verb'GB_bitonic' did not compile with the MS cl
+        compiler.  Found by Erik Welch, NVIDIA.
+    \end{itemize}
+
 \item Dec 3, 2025: version 10.3.0
 
     \begin{itemize}
diff --git a/Include/GraphBLAS.h b/Include/GraphBLAS.h
@@ -1,4 +1,4 @@
-// SuiteSparse:GraphBLAS 10.3.0
+// SuiteSparse:GraphBLAS 10.3.1
 //------------------------------------------------------------------------------
 // GraphBLAS.h: definitions for the GraphBLAS package
 //------------------------------------------------------------------------------
@@ -286,10 +286,10 @@
 
 // The version of this implementation, and the GraphBLAS API version:
 #define GxB_IMPLEMENTATION_NAME "SuiteSparse:GraphBLAS"
-#define GxB_IMPLEMENTATION_DATE "Dec 3, 2025"
+#define GxB_IMPLEMENTATION_DATE "Jan 21, 2026"
 #define GxB_IMPLEMENTATION_MAJOR 10
 #define GxB_IMPLEMENTATION_MINOR 3
-#define GxB_IMPLEMENTATION_SUB   0
+#define GxB_IMPLEMENTATION_SUB   1
 #define GxB_SPEC_DATE "Dec 22, 2023"
 #define GxB_SPEC_MAJOR 2
 #define GxB_SPEC_MINOR 1
diff --git a/README.md b/README.md
@@ -4,7 +4,7 @@ SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2025, All Rights Reserved.
 
 SPDX-License-Identifier: Apache-2.0
 
-VERSION 10.3.0, Dec 3, 2025
+VERSION 10.3.1, Jan 21, 2026
 
 SuiteSparse:GraphBLAS is a complete implementation of the GraphBLAS standard,
 which defines a set of sparse matrix operations on an extended algebra of
diff --git a/Source/global/GB_Global.c b/Source/global/GB_Global.c
@@ -253,7 +253,7 @@ static GB_Global_struct GB_Global =
     .gpu_count = 0,                     // # of GPUs in the system
 
     // OpenMP locks
-    .lock_is_created = {0, 0, 0, 0},
+    .lock_is_created = {0, 0, 0, 0, 0, 0, 0, 0},    // of size GB_GLOBAL_NLOCKS
 } ;
 
 //==============================================================================
diff --git a/Source/jit_wrappers/GB_masker_phase1_jit.c b/Source/jit_wrappers/GB_masker_phase1_jit.c
@@ -29,6 +29,7 @@ GrB_Info GB_masker_phase1_jit       // count nnz in each R(:,j)
     const int64_t *restrict R_to_Z,
     const bool Rp_is_32,            // if true, Rp is 32-bit; else 64-bit
     const bool Rj_is_32,            // if true, Rh is 32-bit; else 64-bit
+    const int R_sparsity,           // GxB_SPARSE or GxB_HYPERSPARSE
     // original input:
     const GrB_Matrix M,             // required mask
     const bool Mask_comp,           // if true, then M is complemented
@@ -45,7 +46,8 @@ GrB_Info GB_masker_phase1_jit       // count nnz in each R(:,j)
     GB_jit_encoding encoding ;
     char *suffix ;
     uint64_t hash = GB_encodify_masker (&encoding, &suffix,
-        GB_JIT_KERNEL_MASKER_PHASE1, NULL, Rp_is_32, Rj_is_32, false,
+        GB_JIT_KERNEL_MASKER_PHASE1, R_sparsity, /* rtype: */ NULL,
+        Rp_is_32, Rj_is_32, /* Ri is not accessed: */ false,
         M, Mask_struct, Mask_comp, C, Z) ;
 
     //--------------------------------------------------------------------------
diff --git a/Source/jit_wrappers/GB_masker_phase2_jit.c b/Source/jit_wrappers/GB_masker_phase2_jit.c
@@ -23,6 +23,7 @@ GrB_Info GB_masker_phase2_jit       // phase2 for R = masker (C,M,Z)
     const int64_t *restrict R_to_M,
     const int64_t *restrict R_to_C,
     const int64_t *restrict R_to_Z,
+    const int R_sparsity,           // any sparsity format
     // original input:
     const GrB_Matrix M,             // required mask
     const bool Mask_comp,           // if true, then M is complemented
@@ -45,7 +46,8 @@ GrB_Info GB_masker_phase2_jit       // phase2 for R = masker (C,M,Z)
     GB_jit_encoding encoding ;
     char *suffix ;
     uint64_t hash = GB_encodify_masker (&encoding, &suffix,
-        GB_JIT_KERNEL_MASKER_PHASE2, R, R->p_is_32, R->j_is_32, R->i_is_32,
+        GB_JIT_KERNEL_MASKER_PHASE2, R_sparsity, R->type,
+        R->p_is_32, R->j_is_32, R->i_is_32,
         M, Mask_struct, Mask_comp, C, Z) ;
 
     //--------------------------------------------------------------------------
diff --git a/Source/jitifyer/GB_encodify_masker.c b/Source/jitifyer/GB_encodify_masker.c
@@ -20,7 +20,8 @@ uint64_t GB_encodify_masker     // encode a masker problem
     char **suffix,              // suffix for user-defined kernel
     // input:
     const GB_jit_kcode kcode,   // kernel to encode
-    const GrB_Matrix R,         // may be NULL, for phase1
+    const int R_sparsity,       // any sparsity format
+    const GrB_Type rtype,
     const bool Rp_is_32,        // if true, R->p is 32 bit; else 64 bit
     const bool Rj_is_32,        // if true, R->h is 32 bit; else 64 bit
     const bool Ri_is_32,        // if true, R->i is 32 bit; else 64 bit
@@ -33,11 +34,10 @@ uint64_t GB_encodify_masker     // encode a masker problem
 { 
 
     //--------------------------------------------------------------------------
-    // check if the R->type is JIT'able
+    // check if the rtype is JIT'able
     //--------------------------------------------------------------------------
 
-    GrB_Type rtype = (R == NULL) ? NULL : R->type ;
-    if (R != NULL && rtype->hash == UINT64_MAX)
+    if (rtype != NULL && rtype->hash == UINT64_MAX)
     { 
         // cannot JIT this type
         memset (encoding, 0, sizeof (GB_jit_encoding)) ;
@@ -50,7 +50,8 @@ uint64_t GB_encodify_masker     // encode a masker problem
     //--------------------------------------------------------------------------
 
     GB_encodify_kcode (encoding, kcode) ;
-    GB_enumify_masker (&encoding->code, R, Rp_is_32, Rj_is_32, Ri_is_32,
+    GB_enumify_masker (&encoding->code, R_sparsity, rtype,
+        Rp_is_32, Rj_is_32, Ri_is_32,
         M, Mask_struct, Mask_comp, C, Z) ;
 
     //--------------------------------------------------------------------------
diff --git a/Source/jitifyer/GB_enumify_masker.c b/Source/jitifyer/GB_enumify_masker.c
@@ -15,7 +15,8 @@ void GB_enumify_masker      // enumify a masker problem
     // output:
     uint64_t *method_code,  // unique encoding of the entire operation
     // input:
-    const GrB_Matrix R,     // NULL for phase 1
+    const int R_sparsity,   // any sparsity format
+    const GrB_Type rtype,   // the type of R (NULL for phase1)
     const bool Rp_is_32,    // if true, R->p is 32-bit; else 64-bit
     const bool Rj_is_32,    // if true, R->h is 32-bit; else 64-bit
     const bool Ri_is_32,    // if true, R->i is 32-bit; else 64-bit
@@ -28,12 +29,11 @@ void GB_enumify_masker      // enumify a masker problem
 { 
 
     //--------------------------------------------------------------------------
-    // get the types of R, C, and Z
+    // check inputs
     //--------------------------------------------------------------------------
 
-    GrB_Type rtype = (R == NULL) ? NULL : R->type ;
-    ASSERT (GB_IMPLIES (R != NULL, rtype == C->type)) ;
-    ASSERT (GB_IMPLIES (R != NULL, rtype == Z->type)) ;
+    ASSERT (GB_IMPLIES (rtype != NULL, rtype == C->type)) ;
+    ASSERT (GB_IMPLIES (rtype != NULL, rtype == Z->type)) ;
 
     //--------------------------------------------------------------------------
     // enumify the types
@@ -55,7 +55,6 @@ void GB_enumify_masker      // enumify a masker problem
     // enumify the sparsity structures of R, C, M, and Z
     //--------------------------------------------------------------------------
 
-    int R_sparsity = GB_sparsity (R) ;
     int C_sparsity = GB_sparsity (C) ;
     int M_sparsity = GB_sparsity (M) ;
     int Z_sparsity = GB_sparsity (Z) ;
diff --git a/Source/jitifyer/GB_stringify.h b/Source/jitifyer/GB_stringify.h
@@ -1573,6 +1573,7 @@ GrB_Info GB_masker_phase1_jit       // count nnz in each R(:,j)
     const int64_t *restrict R_to_Z,
     const bool Rp_is_32,            // if true, Rp is 32-bit; else 64-bit
     const bool Rj_is_32,            // if true, Rh is 32-bit; else 64-bit
+    const int R_sparsity,           // GxB_SPARSE or GxB_HYPERSPARSE
     // original input:
     const GrB_Matrix M,             // required mask
     const bool Mask_comp,           // if true, then M is complemented
@@ -1592,6 +1593,7 @@ GrB_Info GB_masker_phase2_jit       // phase2 for R = masker (C,M,Z)
     const int64_t *restrict R_to_M,
     const int64_t *restrict R_to_C,
     const int64_t *restrict R_to_Z,
+    const int R_sparsity,           // any sparsity format
     // original input:
     const GrB_Matrix M,             // required mask
     const bool Mask_comp,           // if true, then M is complemented
@@ -1614,7 +1616,8 @@ uint64_t GB_encodify_masker     // encode a masker problem
     char **suffix,              // suffix for user-defined kernel
     // input:
     const GB_jit_kcode kcode,   // kernel to encode
-    const GrB_Matrix R,         // may be NULL, for phase1
+    const int R_sparsity,       // GxB_SPARSE or GxB_HYPERSPARSE
+    const GrB_Type rtype,
     const bool Rp_is_32,        // if true, R->p is 32 bit; else 64 bit
     const bool Rj_is_32,        // if true, R->h is 32 bit; else 64 bit
     const bool Ri_is_32,        // if true, R->i is 32 bit; else 64 bit
@@ -1630,7 +1633,8 @@ void GB_enumify_masker      // enumify a masker problem
     // output:
     uint64_t *method_code,  // unique encoding of the entire operation
     // input:
-    const GrB_Matrix R,     // NULL for phase 1
+    const int R_sparsity,   // GxB_SPARSE or GxB_HYPERSPARSE
+    const GrB_Type rtype,   // the type of R (NULL for phase1)
     const bool Rp_is_32,    // if true, R->p is 32-bit; else 64-bit
     const bool Rj_is_32,    // if true, R->h is 32-bit; else 64-bit
     const bool Ri_is_32,    // if true, R->i is 32-bit; else 64-bit
diff --git a/Source/mask/GB_mask.h b/Source/mask/GB_mask.h
@@ -54,6 +54,7 @@ GrB_Info GB_masker_phase1           // count nnz in each R(:,j)
     const int64_t *restrict R_to_Z,
     const bool Rp_is_32,
     const bool Rj_is_32,
+    const int R_sparsity,           // GxB_SPARSE or GxB_HYPERSPARSE
     // original input:
     const GrB_Matrix M,             // required mask
     const bool Mask_comp,           // if true, then M is complemented
@@ -85,7 +86,7 @@ GrB_Info GB_masker_phase2           // phase2 for R = masker (C,M,Z)
     const bool Rp_is_32,
     const bool Rj_is_32,
     const bool Ri_is_32,
-    const int R_sparsity,
+    const int R_sparsity,           // any sparsity format
     // original input:
     const GrB_Matrix M,             // required mask
     const bool Mask_comp,           // if true, then M is complemented
diff --git a/Source/mask/GB_masker.c b/Source/mask/GB_masker.c
@@ -208,7 +208,7 @@ GrB_Info GB_masker          // R = masker (C, M, Z)
             // from phase1a:
             TaskList, R_ntasks, R_nthreads,
             // from phase0:
-            Rnvec, Rh, R_to_M, R_to_C, R_to_Z, Rp_is_32, Rj_is_32,
+            Rnvec, Rh, R_to_M, R_to_C, R_to_Z, Rp_is_32, Rj_is_32, R_sparsity,
             // original input:
             M, Mask_comp, Mask_struct, C, Z, Werk) ;
         if (info != GrB_SUCCESS)
diff --git a/Source/mask/GB_masker_phase1.c b/Source/mask/GB_masker_phase1.c
@@ -43,6 +43,7 @@ GrB_Info GB_masker_phase1           // count nnz in each R(:,j)
     const int64_t *restrict R_to_Z,
     const bool Rp_is_32,
     const bool Rj_is_32,
+    const int R_sparsity,           // GxB_SPARSE or GxB_HYPERSPARSE
     // original input:
     const GrB_Matrix M,             // required mask
     const bool Mask_comp,           // if true, then M is complemented
@@ -60,6 +61,7 @@ GrB_Info GB_masker_phase1           // count nnz in each R(:,j)
     ASSERT (Rp_handle != NULL) ;
     ASSERT (Rp_size_handle != NULL) ;
     ASSERT (Rnvec_nonempty != NULL) ;
+    ASSERT (R_sparsity == GxB_SPARSE || R_sparsity == GxB_HYPERSPARSE) ;
 
     ASSERT_MATRIX_OK (M, "M for mask phase1", GB0) ;
     ASSERT (!GB_ZOMBIES (M)) ; 
@@ -109,7 +111,7 @@ GrB_Info GB_masker_phase1           // count nnz in each R(:,j)
         R_ntasks,                   // # of tasks
         R_nthreads,                 // # of threads to use
         // analysis from phase0:
-        Rnvec, Rh, R_to_M, R_to_C, R_to_Z, Rp_is_32, Rj_is_32,
+        Rnvec, Rh, R_to_M, R_to_C, R_to_Z, Rp_is_32, Rj_is_32, R_sparsity,
         // original input:
         M, Mask_comp, Mask_struct, C, Z) ;
 
diff --git a/Source/mask/GB_masker_phase2.c b/Source/mask/GB_masker_phase2.c
@@ -65,7 +65,7 @@ GrB_Info GB_masker_phase2           // phase2 for R = masker (C,M,Z)
     const bool Rp_is_32,
     const bool Rj_is_32,
     const bool Ri_is_32,
-    const int R_sparsity,
+    const int R_sparsity,           // any sparsity format
     // original input:
     const GrB_Matrix M,             // required mask
     const bool Mask_comp,           // if true, then M is complemented
@@ -243,7 +243,8 @@ GrB_Info GB_masker_phase2           // phase2 for R = masker (C,M,Z)
         //----------------------------------------------------------------------
 
         info = GB_masker_phase2_jit (R, TaskList, R_ntasks, R_nthreads,
-            R_to_M, R_to_C, R_to_Z, M, Mask_comp, Mask_struct, C, Z,
+            R_to_M, R_to_C, R_to_Z, R_sparsity,
+            M, Mask_comp, Mask_struct, C, Z,
             C_ek_slicing, C_ntasks, C_nthreads,
             M_ek_slicing, M_ntasks, M_nthreads) ;
 
diff --git a/cmake_modules/GraphBLAS_version.cmake b/cmake_modules/GraphBLAS_version.cmake
@@ -8,10 +8,10 @@
 #-------------------------------------------------------------------------------
 
 # version of SuiteSparse:GraphBLAS
-set ( GraphBLAS_DATE "Dec 3, 2025" )
+set ( GraphBLAS_DATE "Jan 21, 2026" )
 set ( GraphBLAS_VERSION_MAJOR 10 CACHE STRING "" FORCE )
 set ( GraphBLAS_VERSION_MINOR 3 CACHE STRING "" FORCE )
-set ( GraphBLAS_VERSION_SUB   0 CACHE STRING "" FORCE )
+set ( GraphBLAS_VERSION_SUB   1 CACHE STRING "" FORCE )
 
 # GraphBLAS C API Specification version, at graphblas.org
 set ( GraphBLAS_API_DATE "Dec 22, 2023" )
