PaStiX Handbook  6.2.1
coeftab.c
Go to the documentation of this file.
1 /**
2  *
3  * @file coeftab.c
4  *
5  * PaStiX coefficient array initialization and free routines.
6  *
7  * @copyright 2015-2021 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
8  * Univ. Bordeaux. All rights reserved.
9  *
10  * @version 6.2.0
11  * @author Xavier Lacoste
12  * @author Pierre Ramet
13  * @author Mathieu Faverge
14  * @author Esragul Korkmaz
15  * @author Gregoire Pichon
16  * @author Tony Delarue
17  * @date 2021-03-30
18  *
19  **/
20 #include "common.h"
21 #include "bcsc/bcsc.h"
22 #include "isched.h"
23 #include "blend/solver.h"
24 #include "sopalin/coeftab.h"
25 #include "pastix_zcores.h"
26 #include "pastix_ccores.h"
27 #include "pastix_dcores.h"
28 #include "pastix_scores.h"
29 #include "pastix_zlrcores.h"
30 
31 #if defined(PASTIX_WITH_PARSEC)
33 #endif
34 
35 #if defined(PASTIX_WITH_STARPU)
37 #endif
38 
40 {
42 };
43 
44 /**
45  * @brief Internal structure specific to the parallel call of pcoeftabInit()
46  */
47 struct coeftabinit_s {
48  const SolverMatrix *datacode; /**< The sovler matrix */
49  const pastix_bcsc_t *bcsc; /**< The internal block CSC */
50  const char *dirname; /**< The pointer to the output directory */
51  pastix_coefside_t side; /**< The side of the matrix beeing initialized */
52 };
53 
54 /**
55  *******************************************************************************
56  *
57  * @brief Internal routine called by each static thread to Initialize the solver
58  * matrix structure.
59  *
60  * This routine is the routine called by each thread in the static scheduler and
61  * launched by the coeftabinit().
62  *
63  *******************************************************************************
64  *
65  * @param[inout] ctx
66  * The internal scheduler context
67  *
68  * @param[in] args
69  * The data structure specific to the function cpucblk_zinit()
70  *
71  *******************************************************************************/
72 void
73 pcoeftabInit( isched_thread_t *ctx,
74  void *args )
75 {
76  struct coeftabinit_s *ciargs = (struct coeftabinit_s*)args;
77  const SolverMatrix *datacode = ciargs->datacode;
78  const pastix_bcsc_t *bcsc = ciargs->bcsc;
79  const char *dirname = ciargs->dirname;
80  pastix_coefside_t side = ciargs->side;
81  pastix_int_t i, itercblk;
82  pastix_int_t task;
83  int rank = ctx->rank;
84 
85  void (*initfunc)( pastix_coefside_t, const SolverMatrix*,
86  const pastix_bcsc_t*, pastix_int_t, const char *) = NULL;
87 
88  switch( bcsc->flttype ) {
89  case PastixComplex32:
90  initfunc = cpucblk_cinit;
91  break;
92  case PastixComplex64:
93  initfunc = cpucblk_zinit;
94  break;
95  case PastixFloat:
96  initfunc = cpucblk_sinit;
97  break;
98  case PastixDouble:
99  case PastixPattern:
100  default:
101  initfunc = cpucblk_dinit;
102  }
103 
104  for (i=0; i < datacode->ttsknbr[rank]; i++)
105  {
106  task = datacode->ttsktab[rank][i];
107  itercblk = datacode->tasktab[task].cblknum;
108 
109  /* Init as full rank */
110  initfunc( side, datacode, bcsc, itercblk, dirname );
111  }
112 }
113 
114 /**
115  *******************************************************************************
116  *
117  * @brief Initialize the solver matrix structure
118  *
119  * This routine is a parallel routine to initialize the solver matrix structure
120  * through the internal static scheduler
121  *
122  *******************************************************************************
123  *
124  * @param[inout] pastix_data
125  * The pastix_data structure that hold the solver matrix to initialize.
126  *
127  * @param[in] side
128  * Describe the side(s) of the matrix that must be initialized.
129  * @arg PastixLCoef if lower part only
130  * @arg PastixUCoef if upper part only
131  * @arg PastixLUCoef if both sides.
132  *
133  *******************************************************************************/
134 void
135 coeftabInit( pastix_data_t *pastix_data,
136  pastix_coefside_t side )
137 {
138  struct coeftabinit_s args;
139 
140  args.datacode = pastix_data->solvmatr;
141  args.bcsc = pastix_data->bcsc;
142  args.side = side;
143 
144 #if defined(PASTIX_DEBUG_DUMP_COEFTAB)
145  /* Make sure dir_local is initialized before calling it with multiple threads */
146  pastix_gendirectories( pastix_data );
147 #endif
148  args.dirname = pastix_data->dir_local;
149 
150  /* Initialize ILU level block variables */
151  {
152  SolverCblk *cblk = pastix_data->solvmatr->cblktab;
153  SolverBlok *blok = pastix_data->solvmatr->bloktab;
154  pastix_int_t i;
155 
156  for (i=0; i<pastix_data->solvmatr->cblknbr; i++, cblk++) {
157  cblk->ctrbcnt = cblk[1].brownum - cblk[0].brownum;
158  }
159 
160  for (i=0; i<pastix_data->solvmatr->bloknbr; i++, blok++) {
161  blok->iluklvl = INT_MAX;
162  }
163  }
164  isched_parallel_call( pastix_data->isched, pcoeftabInit, &args );
165 }
166 
167 /**
168  *******************************************************************************
169  *
170  * @brief Free the solver matrix structure
171  *
172  * This routine free all data structure refereing to the solver matrix L, even
173  * the runtime descriptors if present.
174  *
175  *******************************************************************************
176  *
177  * @param[inout] solvmtx
178  * The solver matrix structure of the problem.
179  *
180  *******************************************************************************/
181 void
182 coeftabExit( SolverMatrix *solvmtx )
183 {
184  pastix_int_t i;
185 
186 #if defined(PASTIX_WITH_PARSEC)
187  {
188  if ( solvmtx->parsec_desc != NULL ) {
189  parsec_sparse_matrix_destroy( solvmtx->parsec_desc );
190  free( solvmtx->parsec_desc );
191  }
192  solvmtx->parsec_desc = NULL;
193  }
194 #endif
195 #if defined(PASTIX_WITH_STARPU)
196  {
197  if ( solvmtx->starpu_desc != NULL ) {
198  starpu_sparse_matrix_destroy( solvmtx->starpu_desc );
199  free( solvmtx->starpu_desc );
200  }
201  solvmtx->starpu_desc = NULL;
202  }
203 #endif
204 
205  /* Free arrays of solvmtx */
206  if( solvmtx->cblktab )
207  {
208  SolverCblk *cblk = solvmtx->cblktab;
209 
210  for ( i = 0; i < solvmtx->cblknbr; i++, cblk++ ) {
211  /* Free is precision independent, so we can use any version */
212  if( cblk->cblktype & (CBLK_FANIN|CBLK_RECV) ){
213  continue;
214  }
215  cpucblk_zfree( PastixLUCoef, cblk );
216  }
217  }
218 }
219 
220 /**
221  * @brief Internal structure specific to the parallel call of pcoeftabComp()
222  */
223 struct coeftabcomp_s {
224  SolverMatrix *solvmtx; /**< The sovler matrix */
225  pastix_coeftype_t flttype; /**< The arithmetic type */
226  pastix_atomic_lock_t lock; /**< Lock to protect the gain update */
227  pastix_int_t gain; /**< The memory gain on output */
228 };
229 
230 /**
231  *******************************************************************************
232  *
233  * @brief Internal routine called by each static thread to Initialize the solver
234  * matrix structure.
235  *
236  * This routine is the routine called by each thread in the static scheduler and
237  * launched by the coeftabCompress().
238  *
239  *******************************************************************************
240  *
241  * @param[inout] ctx
242  * The internal scheduler context
243  *
244  * @param[in] args
245  * The data structure specific to the function cpucblk_zcompress()
246  *
247  *******************************************************************************/
248 static void
249 pcoeftabComp( isched_thread_t *ctx,
250  void *args )
251 {
252  struct coeftabcomp_s *ccargs = (struct coeftabcomp_s*)args;
253  SolverMatrix *solvmtx = ccargs->solvmtx;
254  pastix_coeftype_t flttype = ccargs->flttype;
255  pastix_atomic_lock_t *lock = &(ccargs->lock);
256  pastix_int_t *fullgain = &(ccargs->gain);
257  SolverCblk *cblk;
258  pastix_coefside_t side = (solvmtx->factotype == PastixFactLU) ? PastixLUCoef : PastixLCoef;
259  pastix_int_t i, itercblk;
260  pastix_int_t task, gain = 0;
261  int rank = ctx->rank;
262 
263  pastix_int_t (*compfunc)( const SolverMatrix*, pastix_coefside_t, int, SolverCblk* ) = NULL;
264 
265  switch( flttype ) {
266  case PastixComplex32:
267  compfunc = cpucblk_ccompress;
268  break;
269  case PastixComplex64:
270  compfunc = cpucblk_zcompress;
271  break;
272  case PastixFloat:
273  compfunc = cpucblk_scompress;
274  break;
275  case PastixDouble:
276  case PastixPattern:
277  default:
278  compfunc = cpucblk_dcompress;
279  }
280 
281  for (i=0; i < solvmtx->ttsknbr[rank]; i++)
282  {
283  task = solvmtx->ttsktab[rank][i];
284  itercblk = solvmtx->tasktab[task].cblknum;
285  cblk = solvmtx->cblktab + itercblk;
286 
287  if ( cblk->cblktype & CBLK_COMPRESSED ) {
288  gain += compfunc( solvmtx, side, -1, cblk );
289  }
290  }
291 
292  pastix_atomic_lock( lock );
293  *fullgain += gain;
294  pastix_atomic_unlock( lock );
295 }
296 
297 /**
298  *******************************************************************************
299  *
300  * @brief Compress the factorized matrix structure if not already done.
301  *
302  * This routine compress all column blocks that are marked for compression, and
303  * return the amount of memory saved by the compression.
304  *
305  *******************************************************************************
306  *
307  * @param[inout] pastix_data
308  * The pastix_data structure that holds the problem
309  *
310  *******************************************************************************
311  *
312  * @return The memory gain resulting from the compression to low-rank format in
313  * number of elements.
314  *
315  *******************************************************************************/
316 pastix_int_t
317 coeftabCompress( pastix_data_t *pastix_data )
318 {
319  struct coeftabcomp_s args;
320  pastix_lr_t *lr;
321 
322  args.solvmtx = pastix_data->solvmatr;
323  args.flttype = pastix_data->bcsc->flttype;
324  args.lock = PASTIX_ATOMIC_UNLOCKED;
325  args.gain = 0;
326 
327  /* Set the lowrank properties */
328  lr = &(pastix_data->solvmatr->lowrank);
329  lr->compress_method = pastix_data->iparm[IPARM_COMPRESS_METHOD];
330  lr->compress_min_width = pastix_data->iparm[IPARM_COMPRESS_MIN_WIDTH];
331  lr->compress_min_height = pastix_data->iparm[IPARM_COMPRESS_MIN_HEIGHT];
332  lr->tolerance = pastix_data->dparm[DPARM_COMPRESS_TOLERANCE];
333 
334  isched_parallel_call( pastix_data->isched, pcoeftabComp, (void*)(&args) );
335 
336  return args.gain;
337 }
338 
339 #if defined(PASTIX_WITH_MPI)
340 /**
341  *******************************************************************************
342  *
343  * @brief Send all the cblk to their original nodes from the root node.
344  *
345  *******************************************************************************
346  *
347  * @param[inout] solvmtx
348  * The solver matrix to scatter.
349  *
350  * @param[in] comm
351  * MPI communicator
352  *
353  * @param[in] root
354  * Root node from which the solvmtx is scattered.
355  *
356  * @param[in] typesze
357  * Size of the data elements in the SolverMatrix.
358  *
359  ******************************************************************************/
360 void
361 coeftab_scatter( SolverMatrix *solvmtx,
362  PASTIX_Comm comm,
363  pastix_int_t root,
364  pastix_coeftype_t flttype )
365 {
366  static void (*free_fct_array[4])( pastix_coefside_t, SolverCblk * ) = {
368  };
369  void (*free_fct)( pastix_coefside_t, SolverCblk * ) = free_fct_array[ flttype - 2 ];
370  SolverCblk *cblk;
371  pastix_int_t i;
372  MPI_Status status;
373  size_t eltsize = pastix_size_of( flttype );
375 
376  if ( solvmtx->factotype == PastixFactLU ) {
377  side = PastixLUCoef;
378  eltsize *= 2;
379  }
380 
381  cblk = solvmtx->cblktab;
382  for(i=0; i<solvmtx->cblknbr; i++, cblk++)
383  {
384  size_t cblksize = eltsize * cblk->stride * cblk_colnbr( cblk );
385 
386  /* Data which does not belong to the root node must be sent */
387  if ( (solvmtx->clustnum == root) &&
388  (solvmtx->clustnum != cblk->ownerid) )
389  {
390  MPI_Send( cblk->lcoeftab, cblksize, MPI_CHAR,
391  cblk->ownerid, i, comm );
392  free_fct( side, cblk );
393  }
394 
395  /* Data which belongs locally must be received */
396  if ( (solvmtx->clustnum != root) &&
397  (solvmtx->clustnum == cblk->ownerid) )
398  {
399  MPI_Recv( cblk->lcoeftab, cblksize, MPI_CHAR,
400  root, i, comm, &status );
401  }
402  }
403 }
404 
405 /**
406  *******************************************************************************
407  *
408  * @brief Gather all the column blocks on the root node.
409  *
410  *******************************************************************************
411  *
412  * @param[inout] solvmtx
413  * The solver matrix to gather.
414  *
415  * @param[in] comm
416  * MPI communicator
417  *
418  * @param[in] root
419  * Root node on which the solvmtx is gathered.
420  *
421  * @param[in] typesze
422  * Size of the data elements in the SolverMatrix.
423  *
424  ******************************************************************************/
425 void
426 coeftab_gather( SolverMatrix *solvmtx,
427  PASTIX_Comm comm,
428  pastix_int_t root,
429  pastix_coeftype_t flttype )
430 {
431  static void (*alloc_fct_array[4])( pastix_coefside_t, SolverCblk * ) = {
433  };
434  void (*alloc_fct)( pastix_coefside_t, SolverCblk * ) = alloc_fct_array[ flttype - 2 ];
435  SolverCblk *cblk;
436  pastix_int_t i;
437  MPI_Status status;
438  size_t eltsize = pastix_size_of( flttype );
440 
441  if ( solvmtx->factotype == PastixFactLU ) {
442  side = PastixLUCoef;
443  eltsize *= 2;
444  }
445 
446  cblk = solvmtx->cblktab;
447  for( i=0; i<solvmtx->cblknbr; i++, cblk++ )
448  {
449  size_t cblksize = eltsize * cblk->stride * cblk_colnbr( cblk );
450 
451  if ( (solvmtx->clustnum == root) &&
452  (solvmtx->clustnum != cblk->ownerid) )
453  {
454  alloc_fct( side, cblk );
455 
456  MPI_Recv( cblk->lcoeftab, cblksize, MPI_CHAR,
457  cblk->ownerid, i, comm, &status );
458  }
459 
460  if ( (solvmtx->clustnum != root) &&
461  (solvmtx->clustnum == cblk->ownerid) )
462  {
463  MPI_Send( cblk->lcoeftab, cblksize, MPI_CHAR,
464  root, i, comm );
465  }
466  }
467 }
468 
469 /**
470  *******************************************************************************
471  *
472  * @brief Nullify all the distant cblks.
473  *
474  *******************************************************************************
475  *
476  * @param[inout] solvmtx
477  * The solver matrix.
478  *
479  ******************************************************************************/
480 void
481 coeftab_nullify( SolverMatrix *solvmtx )
482 {
483  SolverCblk *cblk;
484  pastix_int_t i;
485  pastix_coefside_t side = ( solvmtx->factotype == PastixFactLU ) ? PastixLUCoef : PastixLCoef;
486 
487  cblk = solvmtx->cblktab;
488  for( i=0; i < solvmtx->cblknbr; i++, cblk++ )
489  {
490  if ( solvmtx->clustnum != cblk->ownerid )
491  {
492  cpucblk_zfree( side, cblk );
493  }
494  }
495 }
496 #endif /* PASTIX_WITH_MPI */
solver_cblk_s::ownerid
int ownerid
Definition: solver.h:146
solver.h
coeftab_cmemory
void coeftab_cmemory(SolverMatrix *solvmtx)
Compute the memory gain of the low-rank form over the full-rank form for the entire matrix.
Definition: coeftab_c.c:232
cblk_colnbr
static pastix_int_t cblk_colnbr(const SolverCblk *cblk)
Compute the number of columns in a column block.
Definition: solver.h:247
pastix_lr_s
Structure to define the type of function to use for the low-rank kernels and their parameters.
Definition: pastix_lowrank.h:147
cpucblk_dcompress
pastix_int_t cpucblk_dcompress(const SolverMatrix *solvmtx, pastix_coefside_t side, int max_ilulvl, SolverCblk *cblk)
Compress a single column block from full-rank to low-rank format.
Definition: cpucblk_dcompress.c:116
cpucblk_sfree
void cpucblk_sfree(pastix_coefside_t side, SolverCblk *cblk)
Free the cblk structure that store the coefficient.
Definition: cpucblk_sinit.c:223
DPARM_COMPRESS_TOLERANCE
@ DPARM_COMPRESS_TOLERANCE
Definition: api.h:173
cpucblk_zinit
void cpucblk_zinit(pastix_coefside_t side, const SolverMatrix *solvmtx, const pastix_bcsc_t *bcsc, pastix_int_t itercblk, const char *directory)
Fully initialize a single cblk.
Definition: coeftab_zinit.c:251
coeftab_dmemory
void coeftab_dmemory(SolverMatrix *solvmtx)
Compute the memory gain of the low-rank form over the full-rank form for the entire matrix.
Definition: coeftab_d.c:232
pastix_bcsc_s
Internal column block distributed CSC matrix.
Definition: bcsc.h:37
solver_cblk_s::stride
pastix_int_t stride
Definition: solver.h:135
solver_cblk_s
Solver column block structure.
Definition: solver.h:127
pastix_coefside_t
enum pastix_coefside_e pastix_coefside_t
Data blocks used in the kernel.
cpucblk_dfree
void cpucblk_dfree(pastix_coefside_t side, SolverCblk *cblk)
Free the cblk structure that store the coefficient.
Definition: cpucblk_dinit.c:223
coeftab_zmemory
void coeftab_zmemory(SolverMatrix *solvmtx)
Compute the memory gain of the low-rank form over the full-rank form for the entire matrix.
Definition: coeftab_z.c:232
pastix_gendirectories
void pastix_gendirectories(pastix_data_t *pastix_data)
Generate a unique temporary directory to store output files.
Definition: api.c:69
cpucblk_calloc
void cpucblk_calloc(pastix_coefside_t side, SolverCblk *cblk)
Allocate the cblk structure to store the coefficient.
Definition: cpucblk_cinit.c:170
pastix_parsec.h
solver_blok_s
Solver block structure.
Definition: solver.h:107
pastix_zcores.h
cpucblk_dinit
void cpucblk_dinit(pastix_coefside_t side, const SolverMatrix *solvmtx, const pastix_bcsc_t *bcsc, pastix_int_t itercblk, const char *directory)
Fully initialize a single cblk.
Definition: coeftab_dinit.c:251
coeftabCompress
pastix_int_t coeftabCompress(pastix_data_t *pastix_data)
Compress the factorized matrix structure if not already done.
Definition: coeftab.c:317
solver_cblk_s::ctrbcnt
volatile uint32_t ctrbcnt
Definition: solver.h:129
pcoeftabComp
static void pcoeftabComp(isched_thread_t *ctx, void *args)
Internal routine called by each static thread to Initialize the solver matrix structure.
Definition: coeftab.c:249
coeftab_fct_memory_t
void(* coeftab_fct_memory_t)(SolverMatrix *)
Type of the memory gain functions.
Definition: coeftab.h:51
IPARM_COMPRESS_MIN_HEIGHT
@ IPARM_COMPRESS_MIN_HEIGHT
Definition: api.h:127
cpucblk_dalloc
void cpucblk_dalloc(pastix_coefside_t side, SolverCblk *cblk)
Allocate the cblk structure to store the coefficient.
Definition: cpucblk_dinit.c:170
IPARM_COMPRESS_METHOD
@ IPARM_COMPRESS_METHOD
Definition: api.h:129
parsec_sparse_matrix_destroy
void parsec_sparse_matrix_destroy(parsec_sparse_matrix_desc_t *desc)
Free the PaRSEC descriptor of the sparse matrix.
Definition: parsec_sparse_matrix.c:727
pastix_bcsc_s::flttype
int flttype
Definition: bcsc.h:41
solver_blok_s::iluklvl
int iluklvl
Definition: solver.h:118
pastix_zlrcores.h
bcsc.h
solver_cblk_s::lcoeftab
void * lcoeftab
Definition: solver.h:142
pastix_dcores.h
pastix_ccores.h
IPARM_COMPRESS_MIN_WIDTH
@ IPARM_COMPRESS_MIN_WIDTH
Definition: api.h:126
pastix_scores.h
cpucblk_scompress
pastix_int_t cpucblk_scompress(const SolverMatrix *solvmtx, pastix_coefside_t side, int max_ilulvl, SolverCblk *cblk)
Compress a single column block from full-rank to low-rank format.
Definition: cpucblk_scompress.c:116
solver_cblk_s::brownum
pastix_int_t brownum
Definition: solver.h:137
PastixLCoef
@ PastixLCoef
Definition: api.h:454
cpucblk_ccompress
pastix_int_t cpucblk_ccompress(const SolverMatrix *solvmtx, pastix_coefside_t side, int max_ilulvl, SolverCblk *cblk)
Compress a single column block from full-rank to low-rank format.
Definition: cpucblk_ccompress.c:116
cpucblk_salloc
void cpucblk_salloc(pastix_coefside_t side, SolverCblk *cblk)
Allocate the cblk structure to store the coefficient.
Definition: cpucblk_sinit.c:170
cpucblk_sinit
void cpucblk_sinit(pastix_coefside_t side, const SolverMatrix *solvmtx, const pastix_bcsc_t *bcsc, pastix_int_t itercblk, const char *directory)
Fully initialize a single cblk.
Definition: coeftab_sinit.c:251
cpucblk_zalloc
void cpucblk_zalloc(pastix_coefside_t side, SolverCblk *cblk)
Allocate the cblk structure to store the coefficient.
Definition: cpucblk_zinit.c:170
cpucblk_cinit
void cpucblk_cinit(pastix_coefside_t side, const SolverMatrix *solvmtx, const pastix_bcsc_t *bcsc, pastix_int_t itercblk, const char *directory)
Fully initialize a single cblk.
Definition: coeftab_cinit.c:251
coeftabExit
void coeftabExit(SolverMatrix *solvmtx)
Free the solver matrix structure.
Definition: coeftab.c:182
pcoeftabInit
void pcoeftabInit(isched_thread_t *ctx, void *args)
Internal routine called by each static thread to Initialize the solver matrix structure.
Definition: coeftab.c:73
coeftabMemory
coeftab_fct_memory_t coeftabMemory[4]
List of functions to compute the memory gain in low-rank per precision.
Definition: coeftab.c:39
solver_cblk_s::cblktype
int8_t cblktype
Definition: solver.h:130
PastixLUCoef
@ PastixLUCoef
Definition: api.h:456
coeftab.h
pastix_starpu.h
PastixFactLU
@ PastixFactLU
Definition: api.h:302
cpucblk_zcompress
pastix_int_t cpucblk_zcompress(const SolverMatrix *solvmtx, pastix_coefside_t side, int max_ilulvl, SolverCblk *cblk)
Compress a single column block from full-rank to low-rank format.
Definition: cpucblk_zcompress.c:116
coeftabInit
void coeftabInit(pastix_data_t *pastix_data, pastix_coefside_t side)
Initialize the solver matrix structure.
Definition: coeftab.c:135
pastix_coeftype_t
#define pastix_coeftype_t
Arithmetic types.
Definition: api.h:281
coeftab_smemory
void coeftab_smemory(SolverMatrix *solvmtx)
Compute the memory gain of the low-rank form over the full-rank form for the entire matrix.
Definition: coeftab_s.c:232
cpucblk_cfree
void cpucblk_cfree(pastix_coefside_t side, SolverCblk *cblk)
Free the cblk structure that store the coefficient.
Definition: cpucblk_cinit.c:223
cpucblk_zfree
void cpucblk_zfree(pastix_coefside_t side, SolverCblk *cblk)
Free the cblk structure that store the coefficient.
Definition: cpucblk_zinit.c:223
starpu_sparse_matrix_destroy
void starpu_sparse_matrix_destroy(starpu_sparse_matrix_desc_t *desc)
Free the StarPU descriptor of the sparse matrix.
Definition: starpu_sparse_matrix.c:453