Kronecker mask

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

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}
 

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}

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

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

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
 } ;
 
 //==============================================================================

Source/jit_kernels/include/GB_jit_kernel_proto.h

@@ -727,7 +727,12 @@ GrB_Info GB_jit_kernel_kroner                                           \
 (                                                                       \
     GrB_Matrix C,                                                       \
     const GrB_Matrix A,                                                 \
+    const bool A_transpose,                                             \
     const GrB_Matrix B,                                                 \
+    const bool B_transpose,                                             \
+    const GrB_Matrix Mask,                                              \
+    const bool Mask_struct,                                             \
+    const bool Mask_comp,                                               \
     const int nthreads,                                                 \
     const void *theta,                                                  \
     const GB_callback_struct *restrict my_callback                      \

Source/jit_wrappers/GB_kroner_jit.c

@@ -20,7 +20,12 @@ GrB_Info GB_kroner_jit
     const GrB_BinaryOp binaryop,
     const bool flipij,
     const GrB_Matrix A,
+    const bool A_transpose,
     const GrB_Matrix B,
+    const bool B_transpose,
+    const GrB_Matrix Mask,
+    const bool Mask_struct,
+    const bool Mask_comp,
     const int nthreads
 )
 { 
@@ -41,7 +46,7 @@ GrB_Info GB_kroner_jit
         GB_JIT_KERNEL_KRONER, /* is_ewisemult: */ false, /* C_iso: */ C->iso,
         /* C_in_iso: */ false, C_sparsity, C->type,
         C->p_is_32, C->j_is_32, C->i_is_32,
-        /* M: */ NULL, true, false, binaryop, flipij, false, A, B) ;
+        /* M: */ Mask, Mask_struct, Mask_comp, binaryop, flipij, false, A, B) ;
 
     //--------------------------------------------------------------------------
     // get the kernel function pointer, loading or compiling it if needed
@@ -60,6 +65,6 @@ GrB_Info GB_kroner_jit
 
     #include "include/GB_pedantic_disable.h"
     GB_jit_dl_function GB_jit_kernel = (GB_jit_dl_function) dl_function ;
-    return (GB_jit_kernel (C, A, B, nthreads, binaryop->theta, &GB_callback)) ;
+    return (GB_jit_kernel (C, A, A_transpose, B, B_transpose, Mask, Mask_struct, Mask_comp, nthreads, binaryop->theta, &GB_callback)) ;
 }
 

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) ;
 
     //--------------------------------------------------------------------------

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) ;
 
     //--------------------------------------------------------------------------

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) ;
 
     //--------------------------------------------------------------------------

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) ;

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
@@ -1833,7 +1837,12 @@ GrB_Info GB_kroner_jit
     const GrB_BinaryOp binaryop,
     const bool flipij,
     const GrB_Matrix A,
+    const bool A_transpose,
     const GrB_Matrix B,
+    const bool B_transpose,
+    const GrB_Matrix Mask,
+    const bool Mask_struct,
+    const bool Mask_comp,
     const int nthreads
 ) ;