some clean up

Author: dance858

include/expr.h

@@ -63,7 +63,7 @@ typedef struct expr
     //                         general quantities
     // ------------------------------------------------------------------------
     int d1, d2, size, n_vars, refcount, var_id;
-    size_t memory_bytes;
+    size_t bytes;
     bool visited;
     struct expr *left;
     struct expr *right;

include/problem.h

@@ -38,7 +38,7 @@ typedef struct
     int nnz_hessian;
     int n_vars;
     int total_constraint_size;
-    size_t memory_bytes;
+    size_t bytes;
 } Diff_engine_stats;
 
 typedef struct problem

include/utils/COO_Matrix.h

@@ -43,6 +43,6 @@ void free_coo_matrix(COO_Matrix *matrix);
 
 /* Returns total bytes used by rows, cols, x, value_map arrays
    (0 if A is NULL) */
-size_t coo_memory_bytes(const COO_Matrix *A);
+size_t coo_bytes(const COO_Matrix *A);
 
 #endif /* COO_MATRIX_H */

include/utils/CSC_Matrix.h

@@ -63,6 +63,6 @@ CSR_Matrix *csc_to_csr_alloc(const CSC_Matrix *A, int *iwork, size_t *mem);
 void csc_to_csr_fill_values(const CSC_Matrix *A, CSR_Matrix *C, int *iwork);
 
 /* Returns total bytes used by p, i, x arrays (0 if A is NULL) */
-size_t csc_memory_bytes(const CSC_Matrix *A);
+size_t csc_bytes(const CSC_Matrix *A);
 
 #endif /* CSC_MATRIX_H */

include/utils/CSR_Matrix.h

@@ -52,7 +52,7 @@ void insert_idx(int idx, int *arr, int len);
 double csr_get_value(const CSR_Matrix *A, int row, int col);
 
 /* Returns total bytes used by p, i, x arrays (0 if A is NULL) */
-size_t csr_memory_bytes(const CSR_Matrix *A);
+size_t csr_bytes(const CSR_Matrix *A);
 
 /* Expand symmetric CSR matrix A to full matrix C. A is assumed to store
    only upper triangle. C must be pre-allocated with sufficient nnz */

include/utils/linalg_dense_sparse_matmuls.h

@@ -8,7 +8,7 @@
 /* C = (I_p kron A) @ J via the polymorphic Matrix interface.
  * A is dense m x n, J is (n*p) x k in CSC, C is (m*p) x k in CSC. */
 // TODO: maybe we can replace these with I_kron_X functionality?
-CSC_Matrix *I_kron_A_alloc(const Matrix *A, const CSC_Matrix *J, int p);
+CSC_Matrix *I_kron_A_alloc(const Matrix *A, const CSC_Matrix *J, int p, size_t *mem);
 void I_kron_A_fill_values(const Matrix *A, const CSC_Matrix *J, CSC_Matrix *C);
 
 /* Sparsity and values of C = (Y^T kron I_m) @ J where Y is k x n, J is (m*k) x p,

include/utils/linalg_sparse_matmuls.h

@@ -14,8 +14,8 @@
     * Mathematically it corresponds to  C = [A @ J1; A @ J2; ...; A @ Jp],
       where J = [J1; J2; ...; Jp]
 */
-CSC_Matrix *block_left_multiply_fill_sparsity(const CSR_Matrix *A,
-                                              const CSC_Matrix *J, int p);
+CSC_Matrix *block_left_multiply_alloc(const CSR_Matrix *A, const CSC_Matrix *J,
+                                      int p, size_t *mem);
 
 void block_left_multiply_fill_values(const CSR_Matrix *A, const CSC_Matrix *J,
                                      CSC_Matrix *C);

include/utils/matrix.h

@@ -28,7 +28,7 @@ typedef struct Matrix
     void (*block_left_mult_vec)(const struct Matrix *self, const double *x,
                                 double *y, int p);
     CSC_Matrix *(*block_left_mult_sparsity)(const struct Matrix *self,
-                                            const CSC_Matrix *J, int p);
+                                            const CSC_Matrix *J, int p, size_t *mem);
     void (*block_left_mult_values)(const struct Matrix *self, const CSC_Matrix *J,
                                    CSC_Matrix *C);
     void (*free_fn)(struct Matrix *self);

src/atoms/affine/add.c

@@ -42,8 +42,7 @@ static void jacobian_init_impl(expr *node)
 
     /* we never have to store more than the sum of children's nnz */
     int nnz_max = node->left->jacobian->nnz + node->right->jacobian->nnz;
-    node->jacobian =
-        new_csr_matrix(node->size, node->n_vars, nnz_max, &node->memory_bytes);
+    node->jacobian = new_csr_matrix(node->size, node->n_vars, nnz_max, &node->bytes);
 
     /* fill sparsity pattern  */
     sum_csr_alloc(node->left->jacobian, node->right->jacobian, node->jacobian);
@@ -68,7 +67,7 @@ static void wsum_hess_init_impl(expr *node)
     /* we never have to store more than the sum of children's nnz */
     int nnz_max = node->left->wsum_hess->nnz + node->right->wsum_hess->nnz;
     node->wsum_hess =
-        new_csr_matrix(node->n_vars, node->n_vars, nnz_max, &node->memory_bytes);
+        new_csr_matrix(node->n_vars, node->n_vars, nnz_max, &node->bytes);
 
     /* fill sparsity pattern of hessian */
     sum_csr_alloc(node->left->wsum_hess, node->right->wsum_hess, node->wsum_hess);

src/atoms/affine/broadcast.c

@@ -93,7 +93,7 @@ static void jacobian_init_impl(expr *node)
     }
 
     node->jacobian =
-        new_csr_matrix(node->size, node->n_vars, total_nnz, &node->memory_bytes);
+        new_csr_matrix(node->size, node->n_vars, total_nnz, &node->bytes);
 
     // ---------------------------------------------------------------------
     //                 fill sparsity pattern
@@ -192,11 +192,11 @@ static void wsum_hess_init_impl(expr *node)
     wsum_hess_init(x);
 
     /* Same sparsity as child - weights get summed */
-    node->wsum_hess = new_csr_copy_sparsity(x->wsum_hess, &node->memory_bytes);
+    node->wsum_hess = new_csr_copy_sparsity(x->wsum_hess, &node->bytes);
 
     /* allocate space for weight vector */
     node->work->dwork = malloc(node->size * sizeof(double));
-    node->memory_bytes += node->size * sizeof(double);
+    node->bytes += node->size * sizeof(double);
 }
 
 static void eval_wsum_hess(expr *node, const double *w)