/*! \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 */