1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
//------------------------------------------------------------------------------
// GB_type: hard-coded functions for each built-in type
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//------------------------------------------------------------------------------
// If this file is in the Generated2/ folder, do not edit it
// (it is auto-generated from Generator/*).
#include "GB.h"
#ifndef GBCUDA_DEV
#include "GB_control.h"
#include "GB_ek_slice.h"
#include "GB_type__include.h"
// The operation is defined by the following types and operators:
// functions:
// C<M>=x (C is as-is-full): GB (_Cdense_05d)
// C<A>=A (C is dense): GB (_Cdense_06d)
// C<M>=A (C is empty, A dense): GB (_Cdense_25)
// C type: GB_ctype
#define GB_CTYPE \
GB_ctype
// C must have the same type as A or the scalar x
#define GB_ATYPE GB_CTYPE
#define GB_CX(p) Cx [p]
// Cx [p] = scalar
#define GB_COPY_SCALAR_TO_C(p,x) Cx [p] = x
// Cx [p] = Ax [pA]
#define GB_COPY_A_TO_C(Cx,p,Ax,pA,A_iso) Cx [p] = GBX (Ax, pA, A_iso)
// test the mask condition with Ax [pA]
#define GB_AX_MASK(Ax,pA,asize) \
GB_ax_mask(Ax,pA,asize)
// hard-coded loops can be vectorized
#define GB_PRAGMA_SIMD_VECTORIZE GB_PRAGMA_SIMD
// disable this operator and use the generic case if these conditions hold
#define GB_DISABLE \
GB_disable
//------------------------------------------------------------------------------
// C<M>=x, when C is dense
//------------------------------------------------------------------------------
GrB_Info GB (_Cdense_05d)
(
GrB_Matrix C,
const GrB_Matrix M,
const bool Mask_struct,
const GB_void *p_cwork, // scalar of type C->type
const int64_t *M_ek_slicing, const int M_ntasks, const int M_nthreads
)
{
#if GB_DISABLE
return (GrB_NO_VALUE) ;
#else
GB_ctype cwork = (*((GB_ctype *) p_cwork)) ;
#include "GB_dense_subassign_05d_template.c"
return (GrB_SUCCESS) ;
#endif
}
//------------------------------------------------------------------------------
// C<A>=A, when C is dense
//------------------------------------------------------------------------------
GrB_Info GB (_Cdense_06d)
(
GrB_Matrix C,
const GrB_Matrix A,
const bool Mask_struct,
const int64_t *A_ek_slicing, const int A_ntasks, const int A_nthreads
)
{
#if GB_DISABLE
return (GrB_NO_VALUE) ;
#else
ASSERT (C->type == A->type) ;
#include "GB_dense_subassign_06d_template.c"
return (GrB_SUCCESS) ;
#endif
}
//------------------------------------------------------------------------------
// C<M>=A, when C is empty and A is dense
//------------------------------------------------------------------------------
GrB_Info GB (_Cdense_25)
(
GrB_Matrix C,
const GrB_Matrix M,
const GrB_Matrix A,
const int64_t *M_ek_slicing, const int M_ntasks, const int M_nthreads
)
{
#if GB_DISABLE
return (GrB_NO_VALUE) ;
#else
ASSERT (C->type == A->type) ;
#include "GB_dense_subassign_25_template.c"
return (GrB_SUCCESS) ;
#endif
}
#endif
|
