Skip to content

Commit 85454b8

Browse files
bodonobodono
committed
clang-format -style="{BasedOnStyle: llvm, IndentWidth: 2, AllowShortFunctionsOnASingleLine: None, KeepEmptyLinesAtTheStartOfBlocks: false}" -i *.{c,h}
1 parent 19f003b commit 85454b8

File tree

20 files changed

+214
-260
lines changed

20 files changed

+214
-260
lines changed

‎linsys/cpu/direct/private.c

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -143,7 +143,7 @@ static ScsMatrix *cs_symperm(const ScsMatrix *A, const scs_int *pinv,
143143
i = Ai[p];
144144
if (i > j) {
145145
continue;
146-
} /* skip lower triangular part of A */
146+
} /* skip lower triangular part of A */
147147
i2 = pinv ? pinv[i] : i; /* row i of A is row i2 of C */
148148
w[MAX(i2, j2)]++; /* column count of C */
149149
}
@@ -155,7 +155,7 @@ static ScsMatrix *cs_symperm(const ScsMatrix *A, const scs_int *pinv,
155155
i = Ai[p];
156156
if (i > j) {
157157
continue;
158-
} /* skip lower triangular part of A*/
158+
} /* skip lower triangular part of A*/
159159
i2 = pinv ? pinv[i] : i; /* row i of A is row i2 of C */
160160
Ci[q = w[MAX(i2, j2)]++] = MIN(i2, j2);
161161
if (Cx) {

‎linsys/csparse.c

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@ ScsMatrix *SCS(cs_spalloc)(scs_int m, scs_int n, scs_int nzmax, scs_int values,
77
ScsMatrix *A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
88
if (!A) {
99
return SCS_NULL;
10-
} /* out of memory */
10+
} /* out of memory */
1111
A->m = m; /* define dimensions and nzmax */
1212
A->n = n;
1313
A->p = (scs_int *)scs_calloc((triplet ? nzmax : n + 1), sizeof(scs_int));

‎linsys/cudss/direct/private.c

Lines changed: 92 additions & 88 deletions
Original file line numberDiff line numberDiff line change
@@ -2,42 +2,35 @@
22
#include "linsys.h"
33

44
/* In case of error abort freeing p */
5-
#define CUDSS_CHECK_ABORT(call, p, fname) \
6-
do \
7-
{ \
8-
cudssStatus_t status = call; \
9-
if (status != CUDSS_STATUS_SUCCESS) \
10-
{ \
11-
scs_printf("CUDSS call " #fname " returned status = %d\n", status); \
12-
scs_free_lin_sys_work(p); \
13-
return SCS_NULL; \
14-
} \
5+
#define CUDSS_CHECK_ABORT(call, p, fname) \
6+
do { \
7+
cudssStatus_t status = call; \
8+
if (status != CUDSS_STATUS_SUCCESS) { \
9+
scs_printf("CUDSS call " #fname " returned status = %d\n", status); \
10+
scs_free_lin_sys_work(p); \
11+
return SCS_NULL; \
12+
} \
1513
} while (0);
1614

1715
/* In case of error abort freeing p */
18-
#define CUDA_CHECK_ABORT(call, p, fname) \
19-
do \
20-
{ \
21-
cudaError_t status = call; \
22-
if (status != cudaSuccess) \
23-
{ \
24-
printf("CUDA call " #fname " returned status = %d\n", status); \
25-
scs_free_lin_sys_work(p); \
26-
return SCS_NULL; \
27-
} \
16+
#define CUDA_CHECK_ABORT(call, p, fname) \
17+
do { \
18+
cudaError_t status = call; \
19+
if (status != cudaSuccess) { \
20+
printf("CUDA call " #fname " returned status = %d\n", status); \
21+
scs_free_lin_sys_work(p); \
22+
return SCS_NULL; \
23+
} \
2824
} while (0);
2925

3026
/* Return the linear system method name */
31-
const char *scs_get_lin_sys_method()
32-
{
27+
const char *scs_get_lin_sys_method() {
3328
return "sparse-direct-cuDSS";
3429
}
3530

3631
/* Free allocated resources for the linear system solver */
37-
void scs_free_lin_sys_work(ScsLinSysWork *p)
38-
{
39-
if (p)
40-
{
32+
void scs_free_lin_sys_work(ScsLinSysWork *p) {
33+
if (p) {
4134
/* Free GPU resources */
4235
if (p->d_kkt_val)
4336
cudaFree(p->d_kkt_val);
@@ -81,8 +74,7 @@ void scs_free_lin_sys_work(ScsLinSysWork *p)
8174

8275
/* Initialize the linear system solver workspace */
8376
ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
84-
const scs_float *diag_r)
85-
{
77+
const scs_float *diag_r) {
8678
ScsLinSysWork *p = scs_calloc(1, sizeof(ScsLinSysWork));
8779
if (!p)
8880
return SCS_NULL;
@@ -94,31 +86,27 @@ ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
9486

9587
/* Allocate CPU memory */
9688
p->sol = (scs_float *)scs_malloc(sizeof(scs_float) * p->n_plus_m);
97-
if (!p->sol)
98-
{
89+
if (!p->sol) {
9990
scs_free_lin_sys_work(p);
10091
return SCS_NULL;
10192
}
10293

10394
p->diag_r_idxs = (scs_int *)scs_calloc(p->n_plus_m, sizeof(scs_int));
104-
if (!p->diag_r_idxs)
105-
{
95+
if (!p->diag_r_idxs) {
10696
scs_free_lin_sys_work(p);
10797
return SCS_NULL;
10898
}
10999

110100
p->diag_p = (scs_float *)scs_calloc(p->n, sizeof(scs_float));
111-
if (!p->diag_p)
112-
{
101+
if (!p->diag_p) {
113102
scs_free_lin_sys_work(p);
114103
return SCS_NULL;
115104
}
116105

117106
/* Form KKT matrix as upper-triangular, CSC */
118107
/* Because of symmetry it is equivalent to lower-triangular, CSR */
119108
p->kkt = SCS(form_kkt)(A, P, p->diag_p, diag_r, p->diag_r_idxs, 1);
120-
if (!p->kkt)
121-
{
109+
if (!p->kkt) {
122110
scs_printf("Error in forming KKT matrix");
123111
scs_free_lin_sys_work(p);
124112
return SCS_NULL;
@@ -131,115 +119,128 @@ ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
131119
CUDSS_CHECK_ABORT(cudssCreate(&p->handle), p, "cudssCreate");
132120
/* Creating cuDSS solver configuration and data objects */
133121

134-
CUDSS_CHECK_ABORT(cudssConfigCreate(&p->solver_config), p, "cudssConfigCreate");
135-
CUDSS_CHECK_ABORT(cudssDataCreate(p->handle, &p->solver_data), p, "cudssDataCreate");
122+
CUDSS_CHECK_ABORT(cudssConfigCreate(&p->solver_config), p,
123+
"cudssConfigCreate");
124+
CUDSS_CHECK_ABORT(cudssDataCreate(p->handle, &p->solver_data), p,
125+
"cudssDataCreate");
136126

137127
/* Allocate device memory for KKT matrix */
138128
scs_int nnz = p->kkt->p[p->n_plus_m];
139129

140-
CUDA_CHECK_ABORT(cudaMalloc((void **)&p->d_kkt_val, nnz * sizeof(scs_float)), p, "cudaMalloc: kkt_val");
141-
CUDA_CHECK_ABORT(cudaMalloc((void **)&p->d_kkt_row_ptr, (p->n_plus_m + 1) * sizeof(scs_int)), p, "cudaMalloc: kkt_row_ptr");
142-
CUDA_CHECK_ABORT(cudaMalloc((void **)&p->d_kkt_col_ind, nnz * sizeof(scs_int)), p, "cudaMalloc: kkt_col_ind");
130+
CUDA_CHECK_ABORT(cudaMalloc((void **)&p->d_kkt_val, nnz * sizeof(scs_float)),
131+
p, "cudaMalloc: kkt_val");
132+
CUDA_CHECK_ABORT(cudaMalloc((void **)&p->d_kkt_row_ptr,
133+
(p->n_plus_m + 1) * sizeof(scs_int)),
134+
p, "cudaMalloc: kkt_row_ptr");
135+
CUDA_CHECK_ABORT(
136+
cudaMalloc((void **)&p->d_kkt_col_ind, nnz * sizeof(scs_int)), p,
137+
"cudaMalloc: kkt_col_ind");
143138

144139
/* Copy KKT matrix to device */
145140
/* Note: we treat column pointers (p->kkt->p) as row pointers on the device */
146141
CUDA_CHECK_ABORT(cudaMemcpy(p->d_kkt_val, p->kkt->x, nnz * sizeof(scs_float),
147142
cudaMemcpyHostToDevice),
148143
p, "cudaMemcpy: kkt_val");
149-
CUDA_CHECK_ABORT(cudaMemcpy(p->d_kkt_row_ptr, p->kkt->p, (p->kkt->n + 1) * sizeof(scs_int),
144+
CUDA_CHECK_ABORT(cudaMemcpy(p->d_kkt_row_ptr, p->kkt->p,
145+
(p->kkt->n + 1) * sizeof(scs_int),
150146
cudaMemcpyHostToDevice),
151147
p, "cudaMemcpy: kkt_row_ptr");
152-
CUDA_CHECK_ABORT(cudaMemcpy(p->d_kkt_col_ind, p->kkt->i, nnz * sizeof(scs_int),
153-
cudaMemcpyHostToDevice),
148+
CUDA_CHECK_ABORT(cudaMemcpy(p->d_kkt_col_ind, p->kkt->i,
149+
nnz * sizeof(scs_int), cudaMemcpyHostToDevice),
154150
p, "cudaMemcpy: kkt_col_ind");
155151

156152
/* Create kkt matrix descriptor */
157153
/* We pass the kkt matrix as symmetric, lower triangular */
158154
cudssMatrixType_t mtype = CUDSS_MTYPE_SYMMETRIC;
159155
cudssMatrixViewType_t mview = CUDSS_MVIEW_LOWER;
160156
cudssIndexBase_t base = CUDSS_BASE_ZERO;
161-
CUDSS_CHECK_ABORT(cudssMatrixCreateCsr(&p->d_kkt_mat, p->kkt->m, p->kkt->n, nnz, p->d_kkt_row_ptr,
162-
NULL, p->d_kkt_col_ind, p->d_kkt_val, SCS_CUDA_INDEX, SCS_CUDA_FLOAT,
163-
mtype, mview, base),
157+
CUDSS_CHECK_ABORT(cudssMatrixCreateCsr(
158+
&p->d_kkt_mat, p->kkt->m, p->kkt->n, nnz,
159+
p->d_kkt_row_ptr, NULL, p->d_kkt_col_ind, p->d_kkt_val,
160+
SCS_CUDA_INDEX, SCS_CUDA_FLOAT, mtype, mview, base),
164161
p, "cudssMatrixCreateCsr");
165162

166163
/* Allocate device memory for vectors */
167-
CUDA_CHECK_ABORT(cudaMalloc((void **)&p->d_b, p->n_plus_m * sizeof(scs_float)), p, "cudaMalloc: b");
168-
CUDA_CHECK_ABORT(cudaMalloc((void **)&p->d_sol, p->n_plus_m * sizeof(scs_float)), p, "cudaMalloc: sol");
164+
CUDA_CHECK_ABORT(
165+
cudaMalloc((void **)&p->d_b, p->n_plus_m * sizeof(scs_float)), p,
166+
"cudaMalloc: b");
167+
CUDA_CHECK_ABORT(
168+
cudaMalloc((void **)&p->d_sol, p->n_plus_m * sizeof(scs_float)), p,
169+
"cudaMalloc: sol");
169170

170171
/* Create RHS and solution matrix descriptors */
171172
scs_int nrhs = 1;
172-
CUDSS_CHECK_ABORT(cudssMatrixCreateDn(&p->d_b_mat, p->n_plus_m, nrhs, p->n_plus_m, p->d_b,
173-
SCS_CUDA_FLOAT, CUDSS_LAYOUT_COL_MAJOR),
173+
CUDSS_CHECK_ABORT(cudssMatrixCreateDn(&p->d_b_mat, p->n_plus_m, nrhs,
174+
p->n_plus_m, p->d_b, SCS_CUDA_FLOAT,
175+
CUDSS_LAYOUT_COL_MAJOR),
174176
p, "cudssMatrixCreateDn: b");
175-
CUDSS_CHECK_ABORT(cudssMatrixCreateDn(&p->d_sol_mat, p->n_plus_m, nrhs, p->n_plus_m, p->d_sol,
176-
SCS_CUDA_FLOAT, CUDSS_LAYOUT_COL_MAJOR),
177+
CUDSS_CHECK_ABORT(cudssMatrixCreateDn(&p->d_sol_mat, p->n_plus_m, nrhs,
178+
p->n_plus_m, p->d_sol, SCS_CUDA_FLOAT,
179+
CUDSS_LAYOUT_COL_MAJOR),
177180
p, "cudssMatrixCreateDn: sol");
178181

179182
/* Symbolic factorization */
180-
CUDSS_CHECK_ABORT(cudssExecute(p->handle, CUDSS_PHASE_ANALYSIS, p->solver_config, p->solver_data,
181-
p->d_kkt_mat, p->d_sol_mat, p->d_b_mat),
183+
CUDSS_CHECK_ABORT(cudssExecute(p->handle, CUDSS_PHASE_ANALYSIS,
184+
p->solver_config, p->solver_data, p->d_kkt_mat,
185+
p->d_sol_mat, p->d_b_mat),
182186
p, "cudssExecute: analysis");
183187

184188
/* Numerical Factorization */
185-
CUDSS_CHECK_ABORT(cudssExecute(p->handle, CUDSS_PHASE_FACTORIZATION, p->solver_config, p->solver_data,
186-
p->d_kkt_mat, p->d_sol_mat, p->d_b_mat),
189+
CUDSS_CHECK_ABORT(cudssExecute(p->handle, CUDSS_PHASE_FACTORIZATION,
190+
p->solver_config, p->solver_data, p->d_kkt_mat,
191+
p->d_sol_mat, p->d_b_mat),
187192
p, "cudssExecute: factorization");
188193

189194
return p;
190195
}
191196

192197
/* Solve the linear system for a given RHS b */
193198
scs_int scs_solve_lin_sys(ScsLinSysWork *p, scs_float *b, const scs_float *ws,
194-
scs_float tol)
195-
{
199+
scs_float tol) {
196200
/* Copy right-hand side to device */
197201
cudaError_t custatus = cudaMemcpy(p->d_b, b, p->n_plus_m * sizeof(scs_float),
198202
cudaMemcpyHostToDevice);
199-
if (custatus != cudaSuccess)
200-
{
201-
scs_printf("scs_solve_lin_sys: Error copying `b` side to device: %d\n", (int)custatus);
203+
if (custatus != cudaSuccess) {
204+
scs_printf("scs_solve_lin_sys: Error copying `b` side to device: %d\n",
205+
(int)custatus);
202206
return custatus;
203207
}
204208

205209
// is this really needed?
206210
cudssMatrixSetValues(p->d_b_mat, p->d_b);
207211

208212
/* Solve the system */
209-
cudssStatus_t status = cudssExecute(p->handle, CUDSS_PHASE_SOLVE, p->solver_config, p->solver_data,
210-
p->d_kkt_mat, p->d_sol_mat, p->d_b_mat);
213+
cudssStatus_t status =
214+
cudssExecute(p->handle, CUDSS_PHASE_SOLVE, p->solver_config,
215+
p->solver_data, p->d_kkt_mat, p->d_sol_mat, p->d_b_mat);
211216

212-
if (status != CUDSS_STATUS_SUCCESS)
213-
{
217+
if (status != CUDSS_STATUS_SUCCESS) {
214218
scs_printf("scs_solve_lin_sys: Error during solve: %d\n", (int)status);
215219
return status;
216220
}
217221

218222
/* Copy solution back to host */
219223
custatus = cudaMemcpy(b, p->d_sol, p->n_plus_m * sizeof(scs_float),
220224
cudaMemcpyDeviceToHost);
221-
if (status != cudaSuccess)
222-
{
223-
scs_printf("scs_solve_lin_sys: Error copying d_sol to host: %d\n", (int)status);
225+
if (status != cudaSuccess) {
226+
scs_printf("scs_solve_lin_sys: Error copying d_sol to host: %d\n",
227+
(int)status);
224228
return status;
225229
}
226230

227231
return 0; /* Success */
228232
}
229233

230234
/* Update the KKT matrix when R changes */
231-
void scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r)
232-
{
235+
void scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
233236
scs_int i;
234237

235238
/* Update KKT matrix on CPU */
236-
for (i = 0; i < p->n; ++i)
237-
{
239+
for (i = 0; i < p->n; ++i) {
238240
/* top left is R_x + P */
239241
p->kkt->x[p->diag_r_idxs[i]] = p->diag_p[i] + diag_r[i];
240242
}
241-
for (i = p->n; i < p->n + p->m; ++i)
242-
{
243+
for (i = p->n; i < p->n + p->m; ++i) {
243244
/* bottom right is -R_y */
244245
p->kkt->x[p->diag_r_idxs[i]] = -diag_r[i];
245246
}
@@ -248,28 +249,31 @@ void scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r)
248249
cudaError_t custatus = cudaMemcpy(p->d_kkt_val, p->kkt->x,
249250
p->kkt->p[p->n_plus_m] * sizeof(scs_float),
250251
cudaMemcpyHostToDevice);
251-
if (custatus != cudaSuccess)
252-
{
253-
scs_printf("scs_update_lin_sys_diag_r: Error copying kkt->x to device: %d\n", (int)custatus);
252+
if (custatus != cudaSuccess) {
253+
scs_printf(
254+
"scs_update_lin_sys_diag_r: Error copying kkt->x to device: %d\n",
255+
(int)custatus);
254256
return;
255257
}
256258

257259
/* Update the matrix values in cuDSS */
258260
cudssStatus_t status;
259-
status = cudssMatrixSetCsrPointers(p->d_kkt_mat, p->d_kkt_row_ptr, NULL, p->d_kkt_col_ind,
260-
p->d_kkt_val);
261-
if (status != CUDSS_STATUS_SUCCESS)
262-
{
263-
scs_printf("scs_update_lin_sys_diag_r: Error updating kkt matrix on device: %d\n", (int)status);
261+
status = cudssMatrixSetCsrPointers(p->d_kkt_mat, p->d_kkt_row_ptr, NULL,
262+
p->d_kkt_col_ind, p->d_kkt_val);
263+
if (status != CUDSS_STATUS_SUCCESS) {
264+
scs_printf(
265+
"scs_update_lin_sys_diag_r: Error updating kkt matrix on device: %d\n",
266+
(int)status);
264267
return;
265268
}
266269

267270
/* Perform Refactorization with the updated matrix */
268-
status = cudssExecute(p->handle, CUDSS_PHASE_REFACTORIZATION, p->solver_config, p->solver_data,
269-
p->d_kkt_mat, p->d_sol_mat, p->d_b_mat);
270-
if (status != CUDSS_STATUS_SUCCESS)
271-
{
272-
scs_printf("scs_update_lin_sys_diag_r: Error during re-factorization: %d\n", (int)status);
271+
status =
272+
cudssExecute(p->handle, CUDSS_PHASE_REFACTORIZATION, p->solver_config,
273+
p->solver_data, p->d_kkt_mat, p->d_sol_mat, p->d_b_mat);
274+
if (status != CUDSS_STATUS_SUCCESS) {
275+
scs_printf("scs_update_lin_sys_diag_r: Error during re-factorization: %d\n",
276+
(int)status);
273277
return;
274278
}
275279
}

0 commit comments

Comments
 (0)