SuperLU 6.0.1
Macros | Functions
cmemory.c File Reference

Memory details. More...

#include "slu_cdefs.h"
Include dependency graph for cmemory.c:

Macros

#define StackFull(x)   ( x + Glu->stack.used >= Glu->stack.size )
 
#define NotDoubleAlign(addr)   ( (intptr_t)addr & 7 )
 
#define DoubleAlign(addr)   ( ((intptr_t)addr + 7) & ~7L )
 
#define TempSpace(m, w)
 
#define Reduce(alpha)   ((alpha + 1) / 2) /* i.e. (alpha-1)/2 + 1 */
 

Functions

void * cexpand (int_t *prev_len, MemType type, int_t len_to_copy, int keep_prev, GlobalLU_t *Glu)
 Expand the existing storage to accommodate more fill-ins. More...
 
int cLUWorkInit (int m, int n, int panel_size, int **iworkptr, complex **dworkptr, GlobalLU_t *Glu)
 Allocate known working storage. Returns 0 if success, otherwise returns the number of bytes allocated so far when failure occurred. More...
 
void copy_mem_complex (int_t, void *, void *)
 
void cStackCompress (GlobalLU_t *Glu)
 Compress the work[] array to remove fragmentation. More...
 
void cSetupSpace (void *work, int_t lwork, GlobalLU_t *Glu)
 Setup the memory model to be used for factorization. More...
 
void * cuser_malloc (int, int, GlobalLU_t *)
 
void cuser_free (int, int, GlobalLU_t *)
 
void copy_mem_int (int, void *, void *)
 
void user_bcopy (char *, char *, int)
 
int cQuerySpace (SuperMatrix *L, SuperMatrix *U, mem_usage_t *mem_usage)
 
int ilu_cQuerySpace (SuperMatrix *L, SuperMatrix *U, mem_usage_t *mem_usage)
 
int_t cLUMemInit (fact_t fact, void *work, int_t lwork, int m, int n, int_t annz, int panel_size, float fill_ratio, SuperMatrix *L, SuperMatrix *U, GlobalLU_t *Glu, int **iwork, complex **dwork)
 Allocate storage for the data structures common to all factor routines. More...
 
void cSetRWork (int m, int panel_size, complex *dworkptr, complex **dense, complex **tempv)
 Set up pointers for real working arrays. More...
 
void cLUWorkFree (int *iwork, complex *dwork, GlobalLU_t *Glu)
 Free the working storage used by factor routines. More...
 
int_t cLUMemXpand (int jcol, int_t next, MemType mem_type, int_t *maxlen, GlobalLU_t *Glu)
 Expand the data structures for L and U during the factorization. More...
 
void callocateA (int n, int_t nnz, complex **a, int_t **asub, int_t **xa)
 Allocate storage for original matrix A. More...
 
complexcomplexMalloc (size_t n)
 
complexcomplexCalloc (size_t n)
 
int_t cmemory_usage (const int_t nzlmax, const int_t nzumax, const int_t nzlumax, const int n)
 

Detailed Description

Copyright (c) 2003, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from U.S. Dept. of Energy)

All rights reserved.

The source code is distributed under BSD license, see the file License.txt at the top-level directory.

-- SuperLU routine (version 4.0) --
Lawrence Berkeley National Laboratory.
June 30, 2009

Macro Definition Documentation

◆ DoubleAlign

#define DoubleAlign (   addr)    ( ((intptr_t)addr + 7) & ~7L )

◆ NotDoubleAlign

#define NotDoubleAlign (   addr)    ( (intptr_t)addr & 7 )

◆ Reduce

#define Reduce (   alpha)    ((alpha + 1) / 2) /* i.e. (alpha-1)/2 + 1 */

◆ StackFull

#define StackFull (   x)    ( x + Glu->stack.used >= Glu->stack.size )

◆ TempSpace

#define TempSpace (   m,
 
)
Value:
( (2*w + 4 + NO_MARKER) * m * sizeof(int) + \
(w + 1) * m * sizeof(complex) )
#define NO_MARKER
Definition: slu_util.h:57
Definition: slu_scomplex.h:31

Function Documentation

◆ callocateA()

void callocateA ( int  n,
int_t  nnz,
complex **  a,
int_t **  asub,
int_t **  xa 
)
Here is the call graph for this function:

◆ cexpand()

void * cexpand ( int_t prev_len,
MemType  type,
int_t  len_to_copy,
int  keep_prev,
GlobalLU_t Glu 
)
Here is the call graph for this function:

◆ cLUMemInit()

int_t cLUMemInit ( fact_t  fact,
void *  work,
int_t  lwork,
int  m,
int  n,
int_t  annz,
int  panel_size,
float  fill_ratio,
SuperMatrix L,
SuperMatrix U,
GlobalLU_t Glu,
int **  iwork,
complex **  dwork 
)

Memory-related.

For those unpredictable size, estimate as fill_ratio * nnz(A).
Return value:
    If lwork = -1, return the estimated amount of space required, plus n;
    otherwise, return the amount of space actually allocated when
    memory allocation failure occurred.
Here is the call graph for this function:

◆ cLUMemXpand()

int_t cLUMemXpand ( int  jcol,
int_t  next,
MemType  mem_type,
int_t maxlen,
GlobalLU_t Glu 
)
Return value:   0 - successful return
              > 0 - number of bytes allocated when run out of space
Here is the call graph for this function:

◆ cLUWorkFree()

void cLUWorkFree ( int *  iwork,
complex dwork,
GlobalLU_t Glu 
)

◆ cLUWorkInit()

int cLUWorkInit ( int  m,
int  n,
int  panel_size,
int **  iworkptr,
complex **  dworkptr,
GlobalLU_t Glu 
)
Here is the call graph for this function:

◆ cmemory_usage()

int_t cmemory_usage ( const int_t  nzlmax,
const int_t  nzumax,
const int_t  nzlumax,
const int  n 
)

◆ complexCalloc()

complex * complexCalloc ( size_t  n)

◆ complexMalloc()

complex * complexMalloc ( size_t  n)

◆ copy_mem_complex()

void copy_mem_complex ( int_t  howmany,
void *  old,
void *  new 
)

◆ copy_mem_int()

void copy_mem_int ( int  ,
void *  ,
void *   
)

◆ cQuerySpace()

int cQuerySpace ( SuperMatrix L,
SuperMatrix U,
mem_usage_t mem_usage 
)

Calculate memory usage

Parameters
mem_usageconsists of the following fields:
  • for_lu (float) The amount of space used in bytes for the L\U data structures.
  • total_needed (float) The amount of space needed in bytes to perform factorization.
Here is the call graph for this function:

◆ cSetRWork()

void cSetRWork ( int  m,
int  panel_size,
complex dworkptr,
complex **  dense,
complex **  tempv 
)
Here is the call graph for this function:

◆ cSetupSpace()

void cSetupSpace ( void *  work,
int_t  lwork,
GlobalLU_t Glu 
)

lwork = 0: use system malloc; lwork > 0: use user-supplied work[] space.

◆ cStackCompress()

void cStackCompress ( GlobalLU_t Glu)
Here is the call graph for this function:

◆ cuser_free()

void cuser_free ( int  bytes,
int  which_end,
GlobalLU_t Glu 
)

◆ cuser_malloc()

void * cuser_malloc ( int  bytes,
int  which_end,
GlobalLU_t Glu 
)

◆ ilu_cQuerySpace()

int ilu_cQuerySpace ( SuperMatrix L,
SuperMatrix U,
mem_usage_t mem_usage 
)

Calculate memory usage

Parameters
mem_usageconsists of the following fields:
  • for_lu (float) The amount of space used in bytes for the L\U data structures.
  • total_needed (float) The amount of space needed in bytes to perform factorization.
Here is the call graph for this function:

◆ user_bcopy()

void user_bcopy ( char *  src,
char *  dest,
int  bytes 
)