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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
//------------------------------------------------------------------------------
// GB_red: hard-coded functions for reductions
//------------------------------------------------------------------------------
// 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_atomics.h"
#include "GB_control.h"
#include "GB_red__include.h"
// The reduction is defined by the following types and operators:
// Assemble tuples: GB (_red_build)
// Reduce to scalar: GB (_red_scalar)
// A type: GB_atype
// C type: GB_ctype
// Reduce: GB_reduce_op(s, aij)
// Identity: GB_identity
// Terminal: GB_terminal
#define GB_ATYPE \
GB_atype
#define GB_CTYPE \
GB_ctype
// monoid identity value
#define GB_IDENTITY \
GB_identity
// declare a scalar and set it equal to the monoid identity value
#define GB_SCALAR_IDENTITY(s) \
GB_ctype s = GB_IDENTITY
// Array to array
// W [k] = (ztype) S [i], with typecast
#define GB_CAST_ARRAY_TO_ARRAY(W,k,S,i) \
W [k] = S [i]
// W [k] += (ztype) S [i], with typecast
#define GB_ADD_CAST_ARRAY_TO_ARRAY(W,k,S,i) \
GB_reduce_op(W [k], S [i])
// W [k] += Ax [p], no typecast
#define GB_ADD_ARRAY_TO_ARRAY(W,k,Ax,p) \
GB_reduce_op(W [k], Ax [p])
// Array to scalar
// s += (ztype) Ax [p], with typecast
#define GB_ADD_CAST_ARRAY_TO_SCALAR(s,Ax,p) \
GB_reduce_op(s, Ax [p])
// s += S [i], no typecast
#define GB_ADD_ARRAY_TO_SCALAR(s,S,i) \
GB_reduce_op(s, S [i])
// Scalar to array
// W [k] = s, no typecast
#define GB_COPY_SCALAR_TO_ARRAY(W,k,s) \
W [k] = s
// break the loop if terminal condition reached
#define GB_HAS_TERMINAL \
GB_has_terminal
#define GB_IS_TERMINAL(s) \
GB_is_terminal
#define GB_TERMINAL_VALUE \
GB_terminal_value
// panel size for built-in operators
#define GB_PANEL \
GB_panel
// special case for the ANY monoid
#define GB_IS_ANY_MONOID \
GB_is_any_monoid
// disable this operator and use the generic case if these conditions hold
#define GB_DISABLE \
GB_disable
//------------------------------------------------------------------------------
// reduce to a non-iso matrix to scalar, for monoids only
//------------------------------------------------------------------------------
if_is_monoid
GrB_Info GB (_red_scalar)
(
GB_atype *result,
const GrB_Matrix A,
GB_void *restrict W_space,
bool *restrict F,
int ntasks,
int nthreads
)
{
#if GB_DISABLE
return (GrB_NO_VALUE) ;
#else
GB_ctype s = (*result) ;
GB_ctype *restrict W = (GB_ctype *) W_space ;
if (A->nzombies > 0 || GB_IS_BITMAP (A))
{
#include "GB_reduce_to_scalar_template.c"
}
else
{
#include "GB_reduce_panel.c"
}
(*result) = s ;
return (GrB_SUCCESS) ;
#endif
}
endif_is_monoid
//------------------------------------------------------------------------------
// build a non-iso matrix
//------------------------------------------------------------------------------
GrB_Info GB (_red_build)
(
GB_atype *restrict Tx,
int64_t *restrict Ti,
const GB_atype *restrict Sx,
int64_t nvals,
int64_t ndupl,
const int64_t *restrict I_work,
const int64_t *restrict K_work,
const int64_t *restrict tstart_slice,
const int64_t *restrict tnz_slice,
int nthreads
)
{
#if GB_DISABLE
return (GrB_NO_VALUE) ;
#else
#include "GB_reduce_build_template.c"
return (GrB_SUCCESS) ;
#endif
}
#endif
|
