/*! \brief Expand the data structures for L and U during the factorization.
*
* <pre>
* Return value: 0 - successful return
* > 0 - number of bytes allocated when run out of space
* </pre>
*/
int
zLUMemXpand(int jcol,
int next, /* number of elements currently in the factors */
MemType mem_type, /* which type of memory to expand */
int *maxlen, /* modified - maximum length of a data structure */
GlobalLU_t *Glu /* modified - global LU data structures */
)
{
void *new_mem;
#ifdef DEBUG
printf("zLUMemXpand(): jcol %d, next %d, maxlen %d, MemType %d\n",
jcol, next, *maxlen, mem_type);
#endif
if (mem_type == USUB)
new_mem = zexpand(maxlen, mem_type, next, 1, Glu);
else
new_mem = zexpand(maxlen, mem_type, next, 0, Glu);
if ( !new_mem ) {
int nzlmax = Glu->nzlmax;
int nzumax = Glu->nzumax;
int nzlumax = Glu->nzlumax;
fprintf(stderr, "Can't expand MemType %d: jcol %d\n", mem_type, jcol);
return (zmemory_usage(nzlmax, nzumax, nzlumax, Glu->n) + Glu->n);
}
switch ( mem_type ) {
case LUSUP:
Glu->lusup = (void *) new_mem;
Glu->nzlumax = *maxlen;
break;
case UCOL:
Glu->ucol = (void *) new_mem;
Glu->nzumax = *maxlen;
break;
case LSUB:
Glu->lsub = (int *) new_mem;
Glu->nzlmax = *maxlen;
break;
case USUB:
Glu->usub = (int *) new_mem;
Glu->nzumax = *maxlen;
break;
}
return 0;
}
void android_main(struct android_app* state)
{
char statepointer[2*sizeof(char*)+3]; // 0x+hex digits+trailing 0
char *argv[] = { "gforth", "starta.fs" };
const int argc = sizeof(argv)/sizeof(char*);
int retvalue;
int checkdir;
int epipe[2];
freopen("/sdcard/gforth/home/aout.log", "w+", stdout);
freopen("/sdcard/gforth/home/aerr.log", "w+", stderr);
pipe(epipe);
fileno(stdin)=epipe[0];
checkdir=open("/sdcard/gforth/" PACKAGE_VERSION, O_RDONLY);
if(checkdir==-1) {
chdir("/sdcard");
zexpand("/data/data/gnu.gforth/lib/libgforthgz.so");
} else {
close(checkdir);
}
state->onAppCmd = engine_handle_cmd;
state->onInputEvent = engine_handle_input;
snprintf(statepointer, sizeof(statepointer), "%p", state);
setenv("HOME", "/sdcard/gforth/home", 1);
setenv("SHELL", "/system/bin/sh", 1);
setenv("libccdir", "/data/data/gnu.gforth/lib", 1);
setenv("LANG", "en_US.UTF-8", 1);
setenv("APP_STATE", statepointer, 1);
app_dummy();
checkdir=open("/sdcard/gforth/site-forth/gforth.fi", O_RDONLY);
if(checkdir==-1) {
chdir("/sdcard/gforth/site-forth");
retvalue=gforth_make_image(0);
} else {
close(checkdir);
}
chdir("/sdcard/gforth/home");
retvalue=gforth_start(argc, argv);
if(retvalue > 0) {
gforth_execute(gforth_find("bootmessage"));
retvalue = gforth_quit();
}
exit(retvalue);
}
/*! \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 */
