From 91bc6fe79b1c34ddef994b32341c250cbd3afd2c Mon Sep 17 00:00:00 2001 From: dance858 Date: Sat, 23 May 2026 05:48:16 -0700 Subject: [PATCH] Use sp_free in src/ to keep memory accounting symmetric --- include/utils/Vec_macros.h | 19 +++++------ include/utils/tracked_alloc.h | 18 +++++++++++ src/atoms/affine/diag_mat.c | 5 +-- src/atoms/affine/hstack.c | 2 +- src/atoms/affine/index.c | 4 +-- src/atoms/affine/left_matmul.c | 2 +- src/atoms/affine/right_matmul.c | 4 +-- src/atoms/affine/sum.c | 2 +- src/atoms/affine/trace.c | 2 +- src/atoms/affine/upper_tri.c | 5 +-- src/atoms/affine/vstack.c | 2 +- src/atoms/bivariate_full_dom/matmul.c | 10 +++--- src/atoms/bivariate_full_dom/multiply.c | 8 ++--- .../bivariate_restricted_dom/quad_over_lin.c | 2 +- src/atoms/other/prod_axis_one.c | 6 ++-- src/atoms/other/prod_axis_zero.c | 6 ++-- src/expr.c | 14 ++++---- src/old-code/linear_op.c | 2 +- src/old-code/old_permuted_dense.c | 12 +++---- src/problem.c | 14 ++++---- src/utils/COO_matrix.c | 10 +++--- src/utils/CSC_matrix.c | 24 +++++++------- src/utils/CSR_matrix.c | 10 +++--- src/utils/int_double_pair.c | 2 +- src/utils/linalg_dense_sparse_matmuls.c | 6 ++-- src/utils/linalg_sparse_matmuls.c | 4 +-- src/utils/permuted_dense.c | 32 +++++++++---------- src/utils/sparse_matrix.c | 6 ++-- src/utils/stacked_pd.c | 22 ++++++------- src/utils/stacked_pd_coalesce.c | 16 +++++----- src/utils/stacked_pd_kron_linalg.c | 16 +++++----- src/utils/stacked_pd_linalg.c | 10 +++--- src/utils/utils.c | 2 +- 33 files changed, 160 insertions(+), 139 deletions(-) diff --git a/include/utils/Vec_macros.h b/include/utils/Vec_macros.h index a6b8cd3..448232e 100644 --- a/include/utils/Vec_macros.h +++ b/include/utils/Vec_macros.h @@ -36,6 +36,7 @@ #ifndef VEC_MACROS_H #define VEC_MACROS_H +#include "utils/tracked_alloc.h" #include #include #include @@ -60,12 +61,12 @@ PSLP_UNUSED static TYPE_NAME##Vec *TYPE_NAME##Vec_new(int capacity) \ { \ assert(capacity > 0); \ - TYPE_NAME##Vec *vec = (TYPE_NAME##Vec *) malloc(sizeof(TYPE_NAME##Vec)); \ + TYPE_NAME##Vec *vec = (TYPE_NAME##Vec *) sp_malloc(sizeof(TYPE_NAME##Vec)); \ if (vec == NULL) return NULL; \ - vec->data = (TYPE *) malloc(capacity * sizeof(TYPE)); \ + vec->data = (TYPE *) sp_malloc(capacity * sizeof(TYPE)); \ if (vec->data == NULL) \ { \ - free(vec); \ + sp_free(vec); \ return NULL; \ } \ \ @@ -76,8 +77,8 @@ \ static inline void TYPE_NAME##Vec_free(TYPE_NAME##Vec *vec) \ { \ - free(vec->data); \ - free(vec); \ + sp_free(vec->data); \ + sp_free(vec); \ } \ \ static inline void TYPE_NAME##Vec_clear_no_resize(TYPE_NAME##Vec *vec) \ @@ -91,8 +92,8 @@ { \ vec->capacity *= 2; \ assert(vec->capacity > 0); \ - TYPE *temp = \ - (TYPE *) realloc(vec->data, (size_t) vec->capacity * sizeof(TYPE)); \ + TYPE *temp = (TYPE *) sp_realloc(vec->data, (size_t) vec->capacity * \ + sizeof(TYPE)); \ if (temp == NULL) \ { \ TYPE_NAME##Vec_free(vec); \ @@ -117,8 +118,8 @@ new_capacity *= 2; \ } \ \ - TYPE *temp = \ - (TYPE *) realloc(vec->data, (size_t) new_capacity * sizeof(TYPE)); \ + TYPE *temp = (TYPE *) sp_realloc(vec->data, \ + (size_t) new_capacity * sizeof(TYPE)); \ if (temp == NULL) \ { \ TYPE_NAME##Vec_free(vec); \ diff --git a/include/utils/tracked_alloc.h b/include/utils/tracked_alloc.h index 33b7077..50c3351 100644 --- a/include/utils/tracked_alloc.h +++ b/include/utils/tracked_alloc.h @@ -77,4 +77,22 @@ static inline void sp_free(void *ptr) } } +static inline void *sp_realloc(void *ptr, size_t size) +{ + size_t old_block_size = ptr ? TRACKED_BLOCK_SIZE(ptr) : 0; + void *new_ptr = realloc(ptr, size); + if (new_ptr) + { + g_allocated_bytes = + g_allocated_bytes - old_block_size + TRACKED_BLOCK_SIZE(new_ptr); + if (g_allocated_bytes > g_peak_bytes) + { + g_peak_bytes = g_allocated_bytes; + } + } + /* realloc returning NULL means failure — original block is still live + per C standard, so no counter adjustment. */ + return new_ptr; +} + #endif /* TRACKED_ALLOC_H */ diff --git a/src/atoms/affine/diag_mat.c b/src/atoms/affine/diag_mat.c index 0d5a7c1..38190e0 100644 --- a/src/atoms/affine/diag_mat.c +++ b/src/atoms/affine/diag_mat.c @@ -16,6 +16,7 @@ * limitations under the License. */ #include "atoms/affine.h" +#include "utils/tracked_alloc.h" #include #include @@ -28,13 +29,13 @@ expr *new_diag_mat(expr *child) assert(child->d1 == child->d2); int n = child->d1; - int *indices = (int *) malloc(n * sizeof(int)); + int *indices = (int *) sp_malloc(n * sizeof(int)); for (int i = 0; i < n; i++) { indices[i] = i * (n + 1); } expr *node = new_index(child, n, 1, indices, n); - free(indices); + sp_free(indices); return node; } diff --git a/src/atoms/affine/hstack.c b/src/atoms/affine/hstack.c index 6b554d9..a139fa6 100644 --- a/src/atoms/affine/hstack.c +++ b/src/atoms/affine/hstack.c @@ -174,7 +174,7 @@ static void free_type_data(expr *node) free_CSR_matrix(hnode->CSR_work); hnode->CSR_work = NULL; - free(hnode->args); + sp_free(hnode->args); hnode->args = NULL; } diff --git a/src/atoms/affine/index.c b/src/atoms/affine/index.c index c41f79c..c0de149 100644 --- a/src/atoms/affine/index.c +++ b/src/atoms/affine/index.c @@ -39,7 +39,7 @@ static bool check_for_duplicates(const int *indices, int n_idxs, int max_idx) } seen[indices[i]] = true; } - free(seen); + sp_free(seen); return has_dup; } @@ -139,7 +139,7 @@ static void free_type_data(expr *node) index_expr *idx = (index_expr *) node; if (idx->indices) { - free(idx->indices); + sp_free(idx->indices); idx->indices = NULL; } } diff --git a/src/atoms/affine/left_matmul.c b/src/atoms/affine/left_matmul.c index 1336ddc..edd36c3 100644 --- a/src/atoms/affine/left_matmul.c +++ b/src/atoms/affine/left_matmul.c @@ -98,7 +98,7 @@ static void free_type_data(expr *node) free_matrix(lnode->AT); free_CSC_matrix(lnode->Jchild_CSC); free_CSC_matrix(lnode->J_CSC); - free(lnode->csc_to_csr_work); + sp_free(lnode->csc_to_csr_work); free_expr(lnode->param_source); lnode->A = NULL; diff --git a/src/atoms/affine/right_matmul.c b/src/atoms/affine/right_matmul.c index f76db91..921767e 100644 --- a/src/atoms/affine/right_matmul.c +++ b/src/atoms/affine/right_matmul.c @@ -76,7 +76,7 @@ expr *new_right_matmul(expr *param_node, expr *u, const CSR_matrix *A) expr *node = new_transpose(left_matmul); free_CSR_matrix(AT); - free(work_transpose); + sp_free(work_transpose); return node; } @@ -107,7 +107,7 @@ expr *new_right_matmul_dense(expr *param_node, expr *u, int m, int n, double *AT = (double *) sp_malloc(n * m * sizeof(double)); A_transpose(AT, data, m, n); left_matmul_node = new_left_matmul_dense(NULL, u_transpose, n, m, AT); - free(AT); + sp_free(AT); } return new_transpose(left_matmul_node); diff --git a/src/atoms/affine/sum.c b/src/atoms/affine/sum.c index 58fe57a..754f262 100644 --- a/src/atoms/affine/sum.c +++ b/src/atoms/affine/sum.c @@ -188,7 +188,7 @@ static bool is_affine(const expr *node) static void free_type_data(expr *node) { sum_expr *snode = (sum_expr *) node; - free(snode->idx_map); + sp_free(snode->idx_map); } expr *new_sum(expr *child, int axis) diff --git a/src/atoms/affine/trace.c b/src/atoms/affine/trace.c index cf25461..ef83710 100644 --- a/src/atoms/affine/trace.c +++ b/src/atoms/affine/trace.c @@ -142,7 +142,7 @@ static void free_type_data(expr *node) if (node) { trace_expr *tnode = (trace_expr *) node; - free(tnode->idx_map); + sp_free(tnode->idx_map); } } diff --git a/src/atoms/affine/upper_tri.c b/src/atoms/affine/upper_tri.c index 2da4d36..1121b93 100644 --- a/src/atoms/affine/upper_tri.c +++ b/src/atoms/affine/upper_tri.c @@ -16,6 +16,7 @@ * limitations under the License. */ #include "atoms/affine.h" +#include "utils/tracked_alloc.h" #include #include @@ -40,7 +41,7 @@ expr *new_upper_tri(expr *child) int *indices = NULL; if (n_elems > 0) { - indices = (int *) malloc(n_elems * sizeof(int)); + indices = (int *) sp_malloc(n_elems * sizeof(int)); int k = 0; for (int i = 0; i < n; i++) { @@ -53,6 +54,6 @@ expr *new_upper_tri(expr *child) } expr *node = new_index(child, n_elems, 1, indices, n_elems); - free(indices); + sp_free(indices); return node; } diff --git a/src/atoms/affine/vstack.c b/src/atoms/affine/vstack.c index 87ecb9b..793427b 100644 --- a/src/atoms/affine/vstack.c +++ b/src/atoms/affine/vstack.c @@ -42,7 +42,7 @@ expr *new_vstack(expr **args, int n_args, int n_vars) } expr *hstacked = new_hstack(transposed, n_args, n_vars); - free(transposed); + sp_free(transposed); return new_transpose(hstacked); } diff --git a/src/atoms/bivariate_full_dom/matmul.c b/src/atoms/bivariate_full_dom/matmul.c index dfc7aaa..7ab72f3 100644 --- a/src/atoms/bivariate_full_dom/matmul.c +++ b/src/atoms/bivariate_full_dom/matmul.c @@ -113,13 +113,13 @@ static void free_matmul_data(expr *node) free_CSR_matrix(mnode->B); free_CSR_matrix(mnode->BJg); free_CSC_matrix(mnode->BJg_CSC); - free(mnode->BJg_csc_work); + sp_free(mnode->BJg_csc_work); free_CSR_matrix(mnode->C); free_CSR_matrix(mnode->CT); - free(mnode->idx_map_C); - free(mnode->idx_map_CT); - free(mnode->idx_map_Hf); - free(mnode->idx_map_Hg); + sp_free(mnode->idx_map_C); + sp_free(mnode->idx_map_CT); + sp_free(mnode->idx_map_Hf); + sp_free(mnode->idx_map_Hg); } static bool is_affine(const expr *node) diff --git a/src/atoms/bivariate_full_dom/multiply.c b/src/atoms/bivariate_full_dom/multiply.c index 93c8e2e..1b183d8 100644 --- a/src/atoms/bivariate_full_dom/multiply.c +++ b/src/atoms/bivariate_full_dom/multiply.c @@ -303,10 +303,10 @@ static void free_type_data(expr *node) elementwise_mult_expr *mul_node = (elementwise_mult_expr *) node; free_matrix(mul_node->C); free_matrix(mul_node->CT); - free(mul_node->idx_map_C); - free(mul_node->idx_map_CT); - free(mul_node->idx_map_Hx); - free(mul_node->idx_map_Hy); + sp_free(mul_node->idx_map_C); + sp_free(mul_node->idx_map_CT); + sp_free(mul_node->idx_map_Hx); + sp_free(mul_node->idx_map_Hy); } static bool is_affine(const expr *node) diff --git a/src/atoms/bivariate_restricted_dom/quad_over_lin.c b/src/atoms/bivariate_restricted_dom/quad_over_lin.c index 4a49843..e6c5b89 100644 --- a/src/atoms/bivariate_restricted_dom/quad_over_lin.c +++ b/src/atoms/bivariate_restricted_dom/quad_over_lin.c @@ -105,7 +105,7 @@ static void jacobian_init_impl(expr *node) } assert(nonzero_cols == jac->nnz); - free(col_nz); + sp_free(col_nz); /* insert y variable index at correct position */ insert_idx(y->var_id, jac->i, jac->nnz); diff --git a/src/atoms/other/prod_axis_one.c b/src/atoms/other/prod_axis_one.c index 5ef7cc6..591657b 100644 --- a/src/atoms/other/prod_axis_one.c +++ b/src/atoms/other/prod_axis_one.c @@ -391,9 +391,9 @@ static bool is_affine(const expr *node) static void free_type_data(expr *node) { prod_axis *pnode = (prod_axis *) node; - free(pnode->num_of_zeros); - free(pnode->zero_index); - free(pnode->prod_nonzero); + sp_free(pnode->num_of_zeros); + sp_free(pnode->zero_index); + sp_free(pnode->prod_nonzero); } expr *new_prod_axis_one(expr *child) diff --git a/src/atoms/other/prod_axis_zero.c b/src/atoms/other/prod_axis_zero.c index b1f51df..b3987ac 100644 --- a/src/atoms/other/prod_axis_zero.c +++ b/src/atoms/other/prod_axis_zero.c @@ -350,9 +350,9 @@ static bool is_affine(const expr *node) static void free_type_data(expr *node) { prod_axis *pnode = (prod_axis *) node; - free(pnode->num_of_zeros); - free(pnode->zero_index); - free(pnode->prod_nonzero); + sp_free(pnode->num_of_zeros); + sp_free(pnode->zero_index); + sp_free(pnode->prod_nonzero); } /* TODO: refactor to remove diagonal entry as nonzero since it's always zero */ diff --git a/src/expr.c b/src/expr.c index 03212c2..30d5b08 100644 --- a/src/expr.c +++ b/src/expr.c @@ -75,25 +75,25 @@ void free_expr(expr *node) } /* free value array and derivative matrices */ - free(node->value); + sp_free(node->value); free_matrix(node->jacobian); free_matrix(node->wsum_hess); /* free workspace */ if (node->work) { - free(node->work->dwork); - free(node->work->iwork); + sp_free(node->work->dwork); + sp_free(node->work->iwork); free_CSC_matrix(node->work->jacobian_csc); - free(node->work->csc_work); - free(node->work->local_jac_diag); + sp_free(node->work->csc_work); + sp_free(node->work->local_jac_diag); free_matrix(node->work->hess_term1); free_matrix(node->work->hess_term2); - free(node->work); + sp_free(node->work); } /* free the node itself */ - free(node); + sp_free(node); } void jacobian_init(expr *node) diff --git a/src/old-code/linear_op.c b/src/old-code/linear_op.c index b66a8d9..739f38d 100644 --- a/src/old-code/linear_op.c +++ b/src/old-code/linear_op.c @@ -55,7 +55,7 @@ static void free_type_data(expr *node) linear_op_expr *lin_node = (linear_op_expr *) node; if (lin_node->b != NULL) { - free(lin_node->b); + sp_free(lin_node->b); lin_node->b = NULL; } } diff --git a/src/old-code/old_permuted_dense.c b/src/old-code/old_permuted_dense.c index 2f3deb1..c05075a 100644 --- a/src/old-code/old_permuted_dense.c +++ b/src/old-code/old_permuted_dense.c @@ -58,8 +58,8 @@ matrix *BTA_pd_csr_alloc(const permuted_dense *B, const CSR_matrix *A) matrix *C = new_permuted_dense(B->base.n, p, B->n0, s_A, B->col_perm, col_active, NULL); - free(col_active); - free(seen); + sp_free(col_active); + sp_free(seen); /* Upgrade `dwork` (currently sized for the Y-role at m0_C * n0_C = B->n0 * s_A) to fit the gather buffer A_sub_dense used by BTA_csr_pd / @@ -69,7 +69,7 @@ matrix *BTA_pd_csr_alloc(const permuted_dense *B, const CSR_matrix *A) size_t gather_size = B->m0 * s_A; if (gather_size > C_pd->kernel_dwork_size) { - free(C_pd->kernel_dwork); + sp_free(C_pd->kernel_dwork); C_pd->kernel_dwork_size = gather_size; C_pd->kernel_dwork = (double *) sp_calloc(gather_size, sizeof(double)); } @@ -191,8 +191,8 @@ matrix *BTA_csr_pd_alloc(const CSR_matrix *B_csr, const permuted_dense *A) matrix *C = new_permuted_dense(q, A->base.n, r_B, A->n0, row_active, A->col_perm, NULL); - free(row_active); - free(seen); + sp_free(row_active); + sp_free(seen); /* Upgrade `dwork` (currently sized for the Y-role at m0_C * n0_C = r_B * A->n0) to fit the gather buffer B_sub_dense used by BTA_csr_pd / @@ -201,7 +201,7 @@ matrix *BTA_csr_pd_alloc(const CSR_matrix *B_csr, const permuted_dense *A) size_t gather_size = A->m0 * r_B; if (gather_size > C_pd->kernel_dwork_size) { - free(C_pd->kernel_dwork); + sp_free(C_pd->kernel_dwork); C_pd->kernel_dwork_size = gather_size; C_pd->kernel_dwork = (double *) sp_calloc(gather_size, sizeof(double)); } diff --git a/src/problem.c b/src/problem.c index b0748af..71872ea 100644 --- a/src/problem.c +++ b/src/problem.c @@ -261,7 +261,7 @@ void problem_init_hessian(problem *prob) int *iwork = (int *) sp_malloc(MAX(nnz, prob->n_vars) * sizeof(int)); problem_lagrange_hess_fill_sparsity(prob, iwork); prob->stats.nnz_hessian = prob->lagrange_hessian->nnz; - free(iwork); + sp_free(iwork); clock_gettime(CLOCK_MONOTONIC, &timer.end); prob->stats.time_init_derivatives += GET_ELAPSED_SECONDS(timer); @@ -361,16 +361,16 @@ void free_problem(problem *prob) } /* Free param_nodes array (weak refs, don't free the nodes) */ - free(prob->param_nodes); + sp_free(prob->param_nodes); /* Free allocated arrays */ - free(prob->constraint_values); - free(prob->gradient_values); + sp_free(prob->constraint_values); + sp_free(prob->gradient_values); free_CSR_matrix(prob->jacobian); free_CSR_matrix(prob->lagrange_hessian); free_COO_matrix(prob->jacobian_coo); free_COO_matrix(prob->lagrange_hessian_coo); - free(prob->hess_idx_map); + sp_free(prob->hess_idx_map); /* Release expression references (decrements refcount) */ free_expr(prob->objective); @@ -378,10 +378,10 @@ void free_problem(problem *prob) { free_expr(prob->constraints[i]); } - free(prob->constraints); + sp_free(prob->constraints); /* Free problem struct */ - free(prob); + sp_free(prob); } void problem_register_params(problem *prob, expr **param_nodes, int n_param_nodes) diff --git a/src/utils/COO_matrix.c b/src/utils/COO_matrix.c index 0cfe2c4..fcbb03a 100644 --- a/src/utils/COO_matrix.c +++ b/src/utils/COO_matrix.c @@ -101,10 +101,10 @@ void free_COO_matrix(COO_matrix *matrix) { if (matrix) { - free(matrix->rows); - free(matrix->cols); - free(matrix->x); - free(matrix->value_map); - free(matrix); + sp_free(matrix->rows); + sp_free(matrix->cols); + sp_free(matrix->x); + sp_free(matrix->value_map); + sp_free(matrix); } } diff --git a/src/utils/CSC_matrix.c b/src/utils/CSC_matrix.c index 5fc5aa1..956cdf6 100644 --- a/src/utils/CSC_matrix.c +++ b/src/utils/CSC_matrix.c @@ -33,10 +33,10 @@ CSC_matrix *new_CSC_matrix(int m, int n, int nnz) if (!matrix->p || !matrix->i || !matrix->x) { - free(matrix->p); - free(matrix->i); - free(matrix->x); - free(matrix); + sp_free(matrix->p); + sp_free(matrix->i); + sp_free(matrix->x); + sp_free(matrix); return NULL; } @@ -51,10 +51,10 @@ void free_CSC_matrix(CSC_matrix *matrix) { if (matrix) { - free(matrix->p); - free(matrix->i); - free(matrix->x); - free(matrix); + sp_free(matrix->p); + sp_free(matrix->i); + sp_free(matrix->x); + sp_free(matrix); } } @@ -106,7 +106,7 @@ CSR_matrix *ATA_alloc(const CSC_matrix *A) symmetrize_csr(Cp, Ci->data, n, C); /* free workspace */ - free(Cp); + sp_free(Cp); iVec_free(Ci); return C; @@ -383,7 +383,7 @@ CSR_matrix *BTA_alloc(const CSC_matrix *A, const CSC_matrix *B) memcpy(C->i, Ci->data, nnz * sizeof(int)); /* free workspace */ - free(Cp); + sp_free(Cp); iVec_free(Ci); return C; @@ -529,8 +529,8 @@ CSC_matrix *symBA_alloc(const CSR_matrix *B, const CSC_matrix *A) memcpy(C->p, Cp, (n + 1) * sizeof(int)); memcpy(C->i, Ci->data, total_nnz * sizeof(int)); - free(marker); - free(Cp); + sp_free(marker); + sp_free(Cp); iVec_free(Ci); return C; diff --git a/src/utils/CSR_matrix.c b/src/utils/CSR_matrix.c index 132e58c..fd13c23 100644 --- a/src/utils/CSR_matrix.c +++ b/src/utils/CSR_matrix.c @@ -58,10 +58,10 @@ void free_CSR_matrix(CSR_matrix *matrix) { if (matrix) { - free(matrix->p); - free(matrix->i); - free(matrix->x); - free(matrix); + sp_free(matrix->p); + sp_free(matrix->i); + sp_free(matrix->x); + sp_free(matrix); } } @@ -296,5 +296,5 @@ void symmetrize_csr(const int *Ap, const int *Ai, int m, CSR_matrix *C) } } - free(counts); + sp_free(counts); } diff --git a/src/utils/int_double_pair.c b/src/utils/int_double_pair.c index 8fe149d..8596cff 100644 --- a/src/utils/int_double_pair.c +++ b/src/utils/int_double_pair.c @@ -46,7 +46,7 @@ void set_int_double_pair_array(int_double_pair *pair, int *ints, double *doubles void free_int_double_pair_array(int_double_pair *array) { - free(array); + sp_free(array); } void sort_int_double_pair_array(int_double_pair *array, int size) diff --git a/src/utils/linalg_dense_sparse_matmuls.c b/src/utils/linalg_dense_sparse_matmuls.c index 6a66841..6211082 100644 --- a/src/utils/linalg_dense_sparse_matmuls.c +++ b/src/utils/linalg_dense_sparse_matmuls.c @@ -85,7 +85,7 @@ CSC_matrix *I_kron_A_alloc(const matrix *A, const CSC_matrix *J, int p) CSC_matrix *C = new_CSC_matrix(m * p, J->n, Ci->len); memcpy(C->p, Cp, (J->n + 1) * sizeof(int)); memcpy(C->i, Ci->data, Ci->len * sizeof(int)); - free(Cp); + sp_free(Cp); iVec_free(Ci); return C; @@ -215,7 +215,7 @@ CSR_matrix *YT_kron_I_alloc(int m, int k, int n, const CSC_matrix *J) { iVec_free(pattern[blk_row]); } - free(pattern); + sp_free(pattern); return C; } @@ -304,7 +304,7 @@ CSR_matrix *I_kron_X_alloc(int m, int k, int n, const CSC_matrix *J) { iVec_free(pattern[blk]); } - free(pattern); + sp_free(pattern); return C; } diff --git a/src/utils/linalg_sparse_matmuls.c b/src/utils/linalg_sparse_matmuls.c index 9ca83c5..f208022 100644 --- a/src/utils/linalg_sparse_matmuls.c +++ b/src/utils/linalg_sparse_matmuls.c @@ -160,7 +160,7 @@ CSC_matrix *block_left_multiply_fill_sparsity(const CSR_matrix *A, CSC_matrix *C = new_CSC_matrix(m * p, J->n, Ci->len); memcpy(C->p, Cp, (J->n + 1) * sizeof(int)); memcpy(C->i, Ci->data, Ci->len * sizeof(int)); - free(Cp); + sp_free(Cp); iVec_free(Ci); return C; @@ -289,7 +289,7 @@ CSR_matrix *csr_csc_matmul_alloc(const CSR_matrix *A, const CSC_matrix *B) CSR_matrix *C = new_CSR_matrix(m, p, nnz); memcpy(C->p, Cp, (m + 1) * sizeof(int)); memcpy(C->i, Ci->data, nnz * sizeof(int)); - free(Cp); + sp_free(Cp); iVec_free(Ci); return C; diff --git a/src/utils/permuted_dense.c b/src/utils/permuted_dense.c index eb058b9..eadf9b6 100644 --- a/src/utils/permuted_dense.c +++ b/src/utils/permuted_dense.c @@ -30,10 +30,10 @@ static void permuted_dense_free(matrix *self) { permuted_dense *pd = (permuted_dense *) self; - free(pd->row_perm); - free(pd->col_perm); - free(pd->col_inv); - free(pd->row_inv); + sp_free(pd->row_perm); + sp_free(pd->col_perm); + sp_free(pd->col_inv); + sp_free(pd->row_inv); /* csr_cache->x aliases pd->X (set in permuted_dense_to_csr_alloc); NULL it so free_CSR_matrix doesn't double-free the shared buffer. */ if (pd->csr_cache != NULL) @@ -43,12 +43,12 @@ static void permuted_dense_free(matrix *self) free_CSR_matrix(pd->csr_cache); if (pd->owns_X) { - free(pd->X); + sp_free(pd->X); } - free(pd->kernel_dwork); - free(pd->kernel_iwork); + sp_free(pd->kernel_dwork); + sp_free(pd->kernel_iwork); free_matrix((matrix *) pd->transpose_cache); - free(pd); + sp_free(pd); } /* permuted_dense has no CSC_matrix mirror; chain-rule kernels operate on X directly. @@ -123,7 +123,7 @@ matrix *index_pd_alloc(const permuted_dense *A, const int *indices, int n_idxs) matrix *out = new_permuted_dense(n_idxs, A->base.n, new_m0, A->n0, new_row_perm, A->col_perm, NULL); - free(new_row_perm); + sp_free(new_row_perm); return out; } @@ -171,7 +171,7 @@ matrix *promote_pd_alloc(const permuted_dense *A, int size) } matrix *out = new_permuted_dense(size, A->base.n, size, A->n0, new_row_perm, A->col_perm, NULL); - free(new_row_perm); + sp_free(new_row_perm); return out; } @@ -253,7 +253,7 @@ matrix *broadcast_pd_alloc(const permuted_dense *A, broadcast_type type, int d1, matrix *out = new_permuted_dense(out_m, A->base.n, new_m0, A->n0, new_row_perm, A->col_perm, NULL); - free(new_row_perm); + sp_free(new_row_perm); return out; } @@ -326,7 +326,7 @@ matrix *diag_vec_pd_alloc(const permuted_dense *A) } matrix *out = new_permuted_dense(out_m, A->base.n, A->m0, A->n0, new_row_perm, A->col_perm, NULL); - free(new_row_perm); + sp_free(new_row_perm); return out; } @@ -504,8 +504,8 @@ matrix *new_permuted_dense_full(int m, int n, const double *data) for (int i = 0; i < m; i++) row_perm[i] = i; for (int j = 0; j < n; j++) col_perm[j] = j; matrix *out = new_permuted_dense(m, n, m, n, row_perm, col_perm, data); - free(row_perm); - free(col_perm); + sp_free(row_perm); + sp_free(col_perm); return out; } @@ -520,7 +520,7 @@ static CSR_matrix *permuted_dense_to_csr_alloc(const permuted_dense *A) CSR_matrix view's value array would hold, so values are always live with no memcpy needed. The PD owns the buffer; permuted_dense_free nulls C->x before free_CSR_matrix to avoid double-free. */ - free(C->x); + sp_free(C->x); C->x = A->X; /* fill column indices (each dense row contributes a copy of col_perm) */ @@ -547,7 +547,7 @@ void permuted_dense_ensure_kernel_dwork(const permuted_dense *pd_const, size_t s * a general function, not necessarily tied to permuted_dense*/ permuted_dense *pd = (permuted_dense *) pd_const; if (pd->kernel_dwork_size >= size) return; - free(pd->kernel_dwork); + sp_free(pd->kernel_dwork); pd->kernel_dwork = (double *) sp_malloc(size * sizeof(double)); pd->kernel_dwork_size = size; } diff --git a/src/utils/sparse_matrix.c b/src/utils/sparse_matrix.c index 0e648f0..04538d8 100644 --- a/src/utils/sparse_matrix.c +++ b/src/utils/sparse_matrix.c @@ -52,9 +52,9 @@ static void sparse_free(matrix *self) sparse_matrix *sm = (sparse_matrix *) self; free_CSR_matrix(sm->csr); free_CSC_matrix(sm->csc_cache); - free(sm->csc_iwork); - free(sm->transpose_iwork); - free(sm); + sp_free(sm->csc_iwork); + sp_free(sm->transpose_iwork); + sp_free(sm); } /* Forward decl: ctor is referenced by copy_sparsity below. */ diff --git a/src/utils/stacked_pd.c b/src/utils/stacked_pd.c index 83d87ab..2310472 100644 --- a/src/utils/stacked_pd.c +++ b/src/utils/stacked_pd.c @@ -35,9 +35,9 @@ static void stacked_pd_free(matrix *self) free_matrix((matrix *) spd->blocks[k]); } - free(spd->blocks); - free(spd->src_block_idx_p); - free(spd->src_block_idx); + sp_free(spd->blocks); + sp_free(spd->src_block_idx_p); + sp_free(spd->src_block_idx); if (spd->pre_coalesce != NULL) { @@ -50,8 +50,8 @@ static void stacked_pd_free(matrix *self) } free_CSR_matrix(spd->csr_cache); - free(spd->base.x); - free(spd); + sp_free(spd->base.x); + sp_free(spd); } /* Vtable adapters — each downcasts matrix * to stacked_pd * and @@ -183,9 +183,9 @@ matrix *spd_map_filter_blocks(const stacked_pd *B, int Cm, int Cn, spd_block_op } matrix *C = new_stacked_pd(Cm, Cn, out_nb, C_blocks, C_src_p, C_src); - free(C_blocks); - free(C_src); - free(C_src_p); + sp_free(C_blocks); + sp_free(C_src); + sp_free(C_src_p); return C; } @@ -213,7 +213,7 @@ void compose_csr_idx_map_for_spd(const stacked_pd *spd, const CSR_matrix *csr, } } memcpy(idx_map, scratch, spd->base.nnz * sizeof(int)); - free(scratch); + sp_free(scratch); } // ----------------------------------------------------------------------------- @@ -291,7 +291,7 @@ static matrix *stacked_pd_vtable_diag_vec_alloc(matrix *self) matrix *out = new_stacked_pd(A->base.m * A->base.m, A->base.n, A->n_blocks, tmp_blocks, NULL, NULL); - free(tmp_blocks); + sp_free(tmp_blocks); return out; } @@ -467,7 +467,7 @@ matrix *new_stacked_pd_unchecked(int m, int n, int n_blocks, permuted_dense **bl } memcpy(spd->base.x + offset, spd->blocks[k]->X, nnz_block * sizeof(double)); - free(spd->blocks[k]->X); + sp_free(spd->blocks[k]->X); spd->blocks[k]->X = spd->base.x + offset; spd->blocks[k]->base.x = spd->blocks[k]->X; spd->blocks[k]->owns_X = false; diff --git a/src/utils/stacked_pd_coalesce.c b/src/utils/stacked_pd_coalesce.c index 99c5d31..33a7edf 100644 --- a/src/utils/stacked_pd_coalesce.c +++ b/src/utils/stacked_pd_coalesce.c @@ -48,9 +48,9 @@ static int_csr *int_csr_create(int *p, int *data, int n) static void int_csr_free(int_csr *csr) { - free(csr->p); - free(csr->data); - free(csr); + sp_free(csr->p); + sp_free(csr->data); + sp_free(csr); } /* Slice of csr->data for key k. Sets *out_len. */ @@ -237,8 +237,8 @@ static permuted_dense **build_output_blocks(const stacked_pd *A, } iVec_free(col_union); - free(col_arrs); - free(col_lens); + sp_free(col_arrs); + sp_free(col_lens); return out_blocks; } @@ -297,13 +297,13 @@ static matrix *coalesce_spd_alloc_impl(const stacked_pd *A, matrix *C = new_stacked_pd(m, n, n_sigs, out_blocks, catalog_sig_p->data, catalog_sig_data->data); - free(out_blocks); + sp_free(out_blocks); int_csr_free(sig_to_rows); - free(row_to_sig); + sp_free(row_to_sig); iVec_free(catalog_sig_p); iVec_free(catalog_sig_data); int_csr_free(row_to_blocks); - free(iwork); + sp_free(iwork); return C; } diff --git a/src/utils/stacked_pd_kron_linalg.c b/src/utils/stacked_pd_kron_linalg.c index 679b7ce..1952ebe 100644 --- a/src/utils/stacked_pd_kron_linalg.c +++ b/src/utils/stacked_pd_kron_linalg.c @@ -63,11 +63,11 @@ static permuted_dense *kron_scratch_init(const permuted_dense *A, int p) /* X_data=NULL leaves the buffer uninitialized; we drop it and alias A->X. */ matrix *pd_m = new_permuted_dense(m * p, n * p, m, n, row_perm, col_perm, NULL); - free(row_perm); - free(col_perm); + sp_free(row_perm); + sp_free(col_perm); permuted_dense *pd = (permuted_dense *) pd_m; - free(pd->X); + sp_free(pd->X); pd->X = A->X; pd->base.x = A->X; pd->owns_X = false; @@ -87,8 +87,8 @@ static permuted_dense *kron_BT_alloc(const permuted_dense *A, int p) for (int j = 0; j < n; j++) row_perm[j] = j; for (int i = 0; i < m; i++) col_perm[i] = i; matrix *BT_m = new_permuted_dense(n * p, m * p, n, m, row_perm, col_perm, NULL); - free(row_perm); - free(col_perm); + sp_free(row_perm); + sp_free(col_perm); return (permuted_dense *) BT_m; } @@ -163,9 +163,9 @@ static matrix *kron_alloc_blockwise(permuted_dense *state, int p, int Cm, int Cn for (int k = 0; k <= out_nb; k++) C_src_p[k] = k; matrix *C = new_stacked_pd(Cm, Cn, out_nb, C_blocks, C_src_p, C_src); - free(C_blocks); - free(C_src); - free(C_src_p); + sp_free(C_blocks); + sp_free(C_src); + sp_free(C_src_p); /* Restore "block 0 set" invariant for the next call. */ kron_scratch_set_block(state, 0, last_k); diff --git a/src/utils/stacked_pd_linalg.c b/src/utils/stacked_pd_linalg.c index 8df8bc7..90a098f 100644 --- a/src/utils/stacked_pd_linalg.c +++ b/src/utils/stacked_pd_linalg.c @@ -42,7 +42,7 @@ matrix *copy_sparsity_spd_alloc(const stacked_pd *A) } matrix *C = new_stacked_pd(A->base.m, A->base.n, n_blocks, C_blocks, NULL, NULL); - free(C_blocks); + sp_free(C_blocks); return C; } @@ -77,7 +77,7 @@ matrix *transpose_spd_alloc(const stacked_pd *A) overlap so use the unchecked constructor. */ matrix *raw = new_stacked_pd_unchecked(A->base.n, A->base.m, n_blocks, AT_blocks, NULL, NULL); - free(AT_blocks); + sp_free(AT_blocks); matrix *C = coalesce_spd_alloc((stacked_pd *) raw); ((stacked_pd *) C)->pre_coalesce = (stacked_pd *) raw; @@ -132,7 +132,7 @@ static matrix *spd_blockwise_alloc_coalesce(const stacked_pd *spd_iter, int Cm, partials[k] = (permuted_dense *) op(spd_iter->blocks[k], ctx); } matrix *raw = new_stacked_pd_unchecked(Cm, Cn, n_blocks, partials, NULL, NULL); - free(partials); + sp_free(partials); matrix *C = coalesce_spd_alloc_unchecked((stacked_pd *) raw); ((stacked_pd *) C)->pre_coalesce = (stacked_pd *) raw; return C; @@ -242,8 +242,8 @@ matrix *BTA_pd_spd_alloc(const permuted_dense *B, const stacked_pd *A) B->col_perm, col_union->data, NULL); iVec_free(col_union); - free(col_perms); - free(lens); + sp_free(col_perms); + sp_free(lens); // ------------------------------------------------------------------------------- // Set up workspace. We need: diff --git a/src/utils/utils.c b/src/utils/utils.c index 6eb105d..179f943 100644 --- a/src/utils/utils.c +++ b/src/utils/utils.c @@ -114,7 +114,7 @@ void sorted_union_int_arrays(const int *const *arrs, const int *lens, int n_arrs } cursor[min_arr]++; } - free(cursor); + sp_free(cursor); } void cumsum(int *p, int n)