void print_uinfos(const char *reply, void *data)
{
zrpc_meta_struct *meta;
zrpc_con *zcon;
Eina_List *users, *l;
zrpc_user *user;
meta = data;
zcon = meta->cbd;
users = meta->extra;
EINA_LIST_FOREACH(users, l, user)
printf("Name: %s\nUID: %d\nLanguage: %s\n", user->name, user->uid, user->language);
EINA_LIST_FREE(users, user)
zuser_free(user);
/*passing a callback for logout isn't really necessary, but why not*/
zrpc_User_logout(zcon, (void*)cleanup, zcon);
}
/*! \brief Allocate storage for the data structures common to all factor routines.
*
* <pre>
* 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.
* </pre>
*/
int
zLUMemInit(fact_t fact, void *work, int lwork, int m, int n, int annz,
int panel_size, double fill_ratio, SuperMatrix *L, SuperMatrix *U,
GlobalLU_t *Glu, int **iwork, doublecomplex **dwork)
{
int info, iword, dword;
SCformat *Lstore;
NCformat *Ustore;
int *xsup, *supno;
int *lsub, *xlsub;
doublecomplex *lusup;
int *xlusup;
doublecomplex *ucol;
int *usub, *xusub;
int nzlmax, nzumax, nzlumax;
iword = sizeof(int);
dword = sizeof(doublecomplex);
Glu->n = n;
Glu->num_expansions = 0;
Glu->expanders = (ExpHeader *) SUPERLU_MALLOC( NO_MEMTYPE *
sizeof(ExpHeader) );
if ( !Glu->expanders ) ABORT("SUPERLU_MALLOC fails for expanders");
if ( fact != SamePattern_SameRowPerm ) {
/* Guess for L\U factors */
nzumax = nzlumax = fill_ratio * annz;
nzlmax = SUPERLU_MAX(1, fill_ratio/4.) * annz;
if ( lwork == -1 ) {
return ( GluIntArray(n) * iword + TempSpace(m, panel_size)
+ (nzlmax+nzumax)*iword + (nzlumax+nzumax)*dword + n );
} else {
zSetupSpace(work, lwork, Glu);
}
#if ( PRNTlevel >= 1 )
printf("zLUMemInit() called: fill_ratio %.0f, nzlmax %ld, nzumax %ld\n",
fill_ratio, nzlmax, nzumax);
fflush(stdout);
#endif
/* Integer pointers for L\U factors */
if ( Glu->MemModel == SYSTEM ) {
xsup = intMalloc(n+1);
supno = intMalloc(n+1);
xlsub = intMalloc(n+1);
xlusup = intMalloc(n+1);
xusub = intMalloc(n+1);
} else {
xsup = (int *)zuser_malloc((n+1) * iword, HEAD, Glu);
supno = (int *)zuser_malloc((n+1) * iword, HEAD, Glu);
xlsub = (int *)zuser_malloc((n+1) * iword, HEAD, Glu);
xlusup = (int *)zuser_malloc((n+1) * iword, HEAD, Glu);
xusub = (int *)zuser_malloc((n+1) * iword, HEAD, Glu);
}
lusup = (doublecomplex *) zexpand( &nzlumax, LUSUP, 0, 0, Glu );
ucol = (doublecomplex *) zexpand( &nzumax, UCOL, 0, 0, Glu );
lsub = (int *) zexpand( &nzlmax, LSUB, 0, 0, Glu );
usub = (int *) zexpand( &nzumax, USUB, 0, 1, Glu );
while ( !lusup || !ucol || !lsub || !usub ) {
if ( Glu->MemModel == SYSTEM ) {
SUPERLU_FREE(lusup);
SUPERLU_FREE(ucol);
SUPERLU_FREE(lsub);
SUPERLU_FREE(usub);
} else {
zuser_free((nzlumax+nzumax)*dword+(nzlmax+nzumax)*iword,
HEAD, Glu);
}
nzlumax /= 2;
nzumax /= 2;
nzlmax /= 2;
if ( nzlumax < annz ) {
printf("Not enough memory to perform factorization.\n");
return (zmemory_usage(nzlmax, nzumax, nzlumax, n) + n);
}
#if ( PRNTlevel >= 1)
printf("zLUMemInit() reduce size: nzlmax %ld, nzumax %ld\n",
nzlmax, nzumax);
fflush(stdout);
#endif
lusup = (doublecomplex *) zexpand( &nzlumax, LUSUP, 0, 0, Glu );
ucol = (doublecomplex *) zexpand( &nzumax, UCOL, 0, 0, Glu );
lsub = (int *) zexpand( &nzlmax, LSUB, 0, 0, Glu );
usub = (int *) zexpand( &nzumax, USUB, 0, 1, Glu );
}
} else {
/* fact == SamePattern_SameRowPerm */
Lstore = L->Store;
Ustore = U->Store;
xsup = Lstore->sup_to_col;
supno = Lstore->col_to_sup;
xlsub = Lstore->rowind_colptr;
xlusup = Lstore->nzval_colptr;
xusub = Ustore->colptr;
nzlmax = Glu->nzlmax; /* max from previous factorization */
nzumax = Glu->nzumax;
nzlumax = Glu->nzlumax;
if ( lwork == -1 ) {
return ( GluIntArray(n) * iword + TempSpace(m, panel_size)
+ (nzlmax+nzumax)*iword + (nzlumax+nzumax)*dword + n );
} else if ( lwork == 0 ) {
Glu->MemModel = SYSTEM;
} else {
Glu->MemModel = USER;
Glu->stack.top2 = (lwork/4)*4; /* must be word-addressable */
Glu->stack.size = Glu->stack.top2;
}
lsub = Glu->expanders[LSUB].mem = Lstore->rowind;
lusup = Glu->expanders[LUSUP].mem = Lstore->nzval;
usub = Glu->expanders[USUB].mem = Ustore->rowind;
ucol = Glu->expanders[UCOL].mem = Ustore->nzval;;
Glu->expanders[LSUB].size = nzlmax;
Glu->expanders[LUSUP].size = nzlumax;
Glu->expanders[USUB].size = nzumax;
Glu->expanders[UCOL].size = nzumax;
}
Glu->xsup = xsup;
Glu->supno = supno;
Glu->lsub = lsub;
Glu->xlsub = xlsub;
Glu->lusup = (void *) lusup;
Glu->xlusup = xlusup;
Glu->ucol = (void *) ucol;
Glu->usub = usub;
Glu->xusub = xusub;
Glu->nzlmax = nzlmax;
Glu->nzumax = nzumax;
Glu->nzlumax = nzlumax;
info = zLUWorkInit(m, n, panel_size, iwork, dwork, Glu);
if ( info )
return ( info + zmemory_usage(nzlmax, nzumax, nzlumax, n) + n);
++Glu->num_expansions;
return 0;
} /* zLUMemInit */