static inline list forward1(list t, int n) { static bucket b[CHARS]; /* buckets */ group g, g2; /* groups */ int pos = 0; /* pos in string */ if (n<2) return t; initmem(groupmem, sizeof(struct grouprec), n/15); initmem(bucketmem, sizeof(struct bucketrec), n/5); /* We use a dummy group g as the header of the group data structure. It does not contain any elements, but only a pointer to the first unfinished group. */ g = (group) allocmem(groupmem, sizeof(struct grouprec)); g2 = (group) allocmem(groupmem, sizeof(struct grouprec)); g->next = g->nextunf = g2; g2->head = t; g2->next = g2->nextunf = NULL; g2->finis = FALSE; intobuckets(g, b, pos); while (g->nextunf) { pos++; intogroups(b, pos); intobuckets(g, b, pos); } t = collect(g); freemem(bucketmem); freemem(groupmem); return t; }
/* attention: should have some upper/lower bound for memory allocation * TODO: slice memory allocation, each slice takes up some amount of * memory, which should be allocated accordingly. */ void schedmem(struct vm_info *vinfo, double capmem, double *tcmem, double *wr, double *mem_est, int n) { int i, ret = 0; double availmem = 0.0, ttaken = 0.0,sum_mem_est = 0.0; for (i = 0; i < n; i++) { ttaken += min(mem_est[i], tcmem[i]); sum_mem_est += mem_est[i]; } availmem = capmem - ttaken; for (i = 0; i < n; i++){ if (mem_est[i] > tcmem[i]) ret = -1; break; } if ((sum_mem_est <= capmem) && (ret == 0)) { for (i = 0; i < n; i++) allocmem(vinfo[i].dp, mem_est[i]); } else if (availmem >= 0.0) { for (i=0; i<n; i++) allocmem(vinfo[i].dp, min(mem_est[i], tcmem[i]) + wr[i] * availmem); } else availmem = 0.0; }
pcluster new_cluster(uint size, uint * idx, uint sons, uint dim) { pcluster t; uint i; t = (pcluster) allocmem((size_t) sizeof(cluster)); t->type = 0; t->size = size; t->dim = dim; t->idx = idx; t->bmin = allocreal(dim); t->bmax = allocreal(dim); t->sons = sons; if (sons > 0) { t->son = (pcluster *) allocmem((size_t) sons * sizeof(pcluster)); for (i = 0; i < sons; i++) t->son[i] = 0; } else t->son = 0; return t; }
pdblock new_dblock(pdcluster rc, pdcluster cc, uint rd, uint cd, uint rsons, uint csons) { pdblock b; uint i, j; b = (pdblock) allocmem(sizeof(dblock)); b->rc = rc; b->cc = cc; b->rd = rd; b->cd = cd; b->adm = false; b->rsons = rsons; b->csons = csons; b->desc = 0; b->son = NULL; if (rsons > 0 && csons > 0) { b->son = (pdblock *) allocmem((size_t) sizeof(dblock) * rsons * csons); for (j = 0; j < csons; j++) for (i = 0; i < rsons; i++) b->son[i + j * rsons] = NULL; } #ifdef USE_OPENMP #pragma omp atomic #endif active_dblock++; return b; }
void *reallocmem(void *pOldAlloc, size_t bytes) { if (0 == pOldAlloc) return allocmem(bytes); size_t *pOldAllocSize = (size_t *) pOldAlloc - 1; void *pNewAlloc = allocmem(bytes); memcpy(pNewAlloc, pOldAlloc, *pOldAllocSize); return pNewAlloc; }
void fill_dlp_cc_far_task_helmholtzbem3d(const uint * ridx, const uint * cidx, pcbem3d bem, bool ntrans, pamatrix N) { nearfield_args *nf_args; nf_args = (nearfield_args *) allocmem(sizeof(nearfield_args)); nf_args->ridx = ridx; nf_args->cidx = cidx; nf_args->dist = true; nf_args->bem = bem; nf_args->ntrans = ntrans; nf_args->N = N; if (nf == NULL) { op_cb.dist = fill_dlp_cc_dist_gpu_wrapper_helmholtzbem3d; op_cb.vert = fill_dlp_cc_vert_gpu_wrapper_helmholtzbem3d; op_cb.edge = fill_dlp_cc_edge_gpu_wrapper_helmholtzbem3d; op_cb.iden = fill_dlp_cc_iden_gpu_wrapper_helmholtzbem3d; op_cb.sing_cpu = fill_dlp_cc_sing_cpu_wrapper_helmholtzbem3d; nf = new_ocltaskgroup(GPU_FIRST, NULL, merge_nf, cleanup_nf_merge, distribute_nf, close_nf, fill_cpu_wrapper_helmholtzbem3d, fill_dlp_cc_dist_gpu_wrapper_helmholtzbem3d, getsize_nf, split_nf_task, cleanup_nf_task, (void *) &op_cb); } add_task_taskgroup(&nf, (void *) nf_args); }
pcurve2d new_curve2d(uint vertices, uint edges) { pcurve2d gr; gr = (pcurve2d) allocmem(sizeof(curve2d)); gr->x = (real(*)[2]) allocmem((size_t) sizeof(real[2]) * vertices); gr->e = (uint(*)[2]) allocmem((size_t) sizeof(uint[2]) * edges); gr->n = (real(*)[2]) allocmem((size_t) sizeof(real[2]) * edges); gr->g = (real *) allocmem((size_t) sizeof(real) * edges); gr->vertices = vertices; gr->edges = edges; return gr; }
bool isclosed_surface3d(pcsurface3d gr) { uint edges = gr->edges; uint triangles = gr->triangles; const uint(*s)[3] = (const uint(*)[3]) gr->s; int *visits; uint i, j, problems; visits = (int *) allocmem((size_t) sizeof(int) * edges); for (i = 0; i < edges; i++) visits[i] = 0; for (i = 0; i < triangles; i++) for (j = 0; j < 3; j++) visits[s[i][j]]++; problems = 0; for (i = 0; i < edges; i++) if (visits[i] != 2) problems++; freemem(visits); return (problems == 0); }
char *Kos_FileRead(kosFileInfo &fileInfo, int &code) { char buffer[512], *p, *r; fileInfo.dataCount = 512; fileInfo.rwMode = 0; fileInfo.bufferPtr = (Byte *)buffer; memset((Byte*)buffer, 0, 512); int z = kos_FileSystemAccess(&fileInfo); code = z; //sprintf(debuf, "kos file read %U", code); //rtlDebugOutString(debuf); if (z != 0 && z != 6) return NULL; p = buffer; while (*p && *p++ != '\n'); if (p == buffer) return NULL; r = (char*)allocmem(p - buffer); memset((Byte*)r, 0, p - buffer); //strncpy(r, buffer, p - buffer); for (int l = 0; l < p - buffer - 1; l++) r[l] = buffer[l]; fileInfo.OffsetLow += p - buffer; return r; }
char *make_cell_name(int x, int y, int xd, int yd) { char *col_cap = make_col_cap(x); char *row_cap = make_row_cap(y); if (x <= 0 || x > col_count || y <= 0 || y > row_count) return NULL; char *res = (char*)allocmem(strlen(col_cap) + strlen(row_cap) + xd ? 1 : 0 + yd ? 1 : 0 + 1); int i = 0; if (xd) { res[i] = '$'; i++; } strcpy(res + i, col_cap); i += strlen(col_cap); if (yd) { res[i] = '$'; i++; } strcpy(res + i, row_cap); i += strlen(row_cap); res[i] = '\0'; freemem(col_cap); freemem(row_cap); return res; }
bool VDDisableCPUTracking() { HKEY hOpen; DWORD cbData; DWORD dwType; LPBYTE pByte; DWORD rc; bool fSuccess = true; if ( (rc = RegOpenKeyEx(HKEY_DYN_DATA,"PerfStats\\StopStat", 0, KEY_READ, &hOpen)) == ERROR_SUCCESS) { // query to get data size if ( (rc = RegQueryValueEx(hOpen,"KERNEL\\CPUUsage",NULL,&dwType, NULL, &cbData )) == ERROR_SUCCESS) { pByte = (LPBYTE)allocmem(cbData); rc = RegQueryValueEx(hOpen,"KERNEL\\CPUUsage",NULL,&dwType, pByte, &cbData ); freemem(pByte); } else fSuccess = false; RegCloseKey(hOpen); } else fSuccess = false; return fSuccess; }
PRIVATE void run_finalize_queue(void) { OBJ *x; x = allocmem(sizeof(OBJ)); *x = NULL; protect(x); wait_for_finalize(); *x = next_to_finalize(); while (*x != NULL) { if (OVECTORP(*x)) { finalize_ovector((OVECTOR) (*x)); } else { /* %%% NOTE here's where objects should be handed to user level to finalize. %%% */ *x = NULL; /* GC's the object */ } *x = next_to_finalize(); } unprotect(x); freemem(x); }
static void push(list head, list tail, int size, int pos) { stackp = (stack *) allocmem(stackmem, sizeof(struct stackrec)); stackp->head = head; stackp->tail = tail; stackp->size = size; stackp->pos = pos; }
intcel* (mkintcel)(entry n with_line_and_file) { intcel *i; i = (intcel*) allocmem(sizeof(intcel)); set_common_fields(i,INTEGER); i->intval = n; return i; }
bigint* (mkbigint)(long size with_line_and_file) { bigint *result; if (size>SHRT_MAX) error("Big integer too big\n"); result = (bigint*)allocmem(sizeof(bigint)+size*sizeof(digit)); set_common_fields(result,BIGINT); result->allocsize = result->size = size; result->data = (digit *)&result[1]; return result; }
bool isoriented_surface3d(pcsurface3d gr) { uint edges = gr->edges; uint triangles = gr->triangles; const uint(*e)[2] = (const uint(*)[2]) gr->e; const uint(*t)[3] = (const uint(*)[3]) gr->t; const uint(*s)[3] = (const uint(*)[3]) gr->s; int *visits, *svisits; uint i, j, k, problems; visits = (int *) allocmem((size_t) sizeof(int) * edges); svisits = (int *) allocmem((size_t) sizeof(int) * edges); for (i = 0; i < edges; i++) visits[i] = svisits[i] = 0; for (i = 0; i < triangles; i++) for (j = 0; j < 3; j++) { k = s[i][j]; visits[k]++; if (e[k][0] == t[i][(j + 1) % 3]) { assert(e[k][1] == t[i][(j + 2) % 3]); svisits[k]++; } else { assert(e[k][0] == t[i][(j + 2) % 3]); assert(e[k][1] == t[i][(j + 1) % 3]); svisits[k]--; } } problems = 0; for (i = 0; i < edges; i++) if (visits[i] > 1 && (svisits[i] < -1 || svisits[i] > 1)) problems++; freemem(svisits); freemem(visits); return (problems == 0); }
pclusteroperator new_leaf_clusteroperator(pccluster t) { pclusteroperator co; co = (pclusteroperator) allocmem(sizeof(clusteroperator)); init_leaf_clusteroperator(co, t); return co; }
pclusteroperator * enumerate_clusteroperator(pccluster t, pclusteroperator co) { pclusteroperator *con; con = allocmem((size_t) sizeof(pclusteroperator) * co->t->desc); enumerate(t, 0, co, con); return con; }
pcluster * enumerate_cluster(pcluster t) { pcluster *tn; tn = (pcluster *) allocmem((size_t) sizeof(pcluster) * t->desc); enumerate(t, 0, tn); return tn; }
ptri2dbuilder new_tri2dbuilder(uint vertices) { ptri2dbuilder tb; uint i; tb = (ptri2dbuilder) allocmem(sizeof(tri2dbuilder)); tb->x = (real(*)[2]) allocmem(sizeof(real[2]) * vertices); tb->elist = (pedgeentry *) allocmem(sizeof(pedgeentry) * vertices); tb->tlist = 0; tb->vertices = vertices; tb->edges = 0; tb->triangles = 0; for (i = 0; i < vertices; i++) tb->elist[i] = 0; return tb; }
pdblock * enumerate_dblock(pdblock b) { pdblock *bn; bn = (pdblock *) allocmem((size_t) sizeof(pdblock) * b->desc); enumerate(b, 0, bn); return bn; }
ptet3dbuilder new_tet3dbuilder(uint vertices) { ptet3dbuilder tb; uint i; tb = (ptet3dbuilder) allocmem(sizeof(tet3dbuilder)); tb->x = (real(*)[3]) allocmem(sizeof(real[3]) * vertices); tb->elist = (pedgeentry *) allocmem(sizeof(pedgeentry) * vertices); tb->tlist = 0; tb->vertices = vertices; tb->edges = 0; tb->faces = 0; tb->tetrahedra = 0; for (i = 0; i < vertices; i++) tb->elist[i] = 0; return tb; }
double depend_callback(char *str) { cell_list *cur; // надо выдрать из АВ47 значения х и у. int i,j,x,y; if (abort_calc == 1) return 0.0; if (*str == '$') str++; for (i = 0; i < strlen(str); i++) if (str[i] >= '0' && str[i] <= '9') break; if (str[i-1] == '$') i--; if (i == strlen(str)) { abort_calc = 1; serror(ERR_BADVARIABLE); return 0.0; } x = -1; for (j = 1; j < col_count; j++) //if (strncmp(str,cells[j][0],i)==0) if (str[0] == cells[j][0][0] && ((i == 1) || (str[1] == cells[j][0][1]))) { x = j; break; } if (str[i] == '$') i++; y = -1; for (j = 1; j < row_count; j++) if (strcmp(str+i,cells[0][j])==0) { y = j; break; } if (x == -1 || y == -1) { abort_calc = 1; serror(ERR_BADVARIABLE); return 0.0; } cur = (cell_list*)allocmem(sizeof(cell_list)); cur->x = x; cur->y = y; cur->next = last_dep; last_dep = cur; return 0.0; }
/* ** 'link_library' is called to add a library to the relevant library list */ static void link_library(char *name, byte *base, int32 size, boolean onheap) { library *lp; int n; if (onheap) { /* Library is held on Basic heap */ lp = allocmem(sizeof(library)); /* Add library to list */ lp->libname = allocmem(strlen(name)+1); /* +1 for NULL at end */ lp->libflink = basicvars.liblist; basicvars.liblist = lp; } else { /* Library is held in permanent memory */ lp = malloc(sizeof(library)); if (lp==NIL) error(ERR_LIBSIZE, name); /* Run out of memory */ lp->libname = malloc(strlen(name)+1); lp->libflink = basicvars.installist; basicvars.installist = lp; } strcpy(lp->libname, name); lp->libstart = base; lp->libsize = size; lp->libfplist = NIL; for (n=0; n<VARLISTS; n++) lp->varlists[n] = NIL; }
void setsons_cluster(pcluster t, uint sons) { uint i; assert(t->sons == 0); t->sons = sons; t->son = (pcluster *) allocmem(sizeof(pcluster) * sons); for (i = 0; i < sons; i++) t->son[i] = 0; }
static pedgeentry new_edgeentry(uint name, uint v0, uint v1, pedgeentry next) { pedgeentry e; e = (pedgeentry) allocmem(sizeof(edgeentry)); e->name = name; e->v[0] = v0; e->v[1] = v1; e->neighbours = 0; e->next = next; return e; }
// -"- строки char *make_row_cap(int i) { char *r = (char*)allocmem(3); if (i <= 9) { r[0] = '0' + i; r[1] = '\0'; return r; } r[0] = (i / 10) + '0'; r[1] = (i % 10) + '0'; r[2] = '\0'; return r; }
static pedgeentry new_edgeentry(uint name, uint v0, uint v1, pedgeentry next) { pedgeentry e; e = (pedgeentry) allocmem(sizeof(edgeentry)); e->name = name; e->v[0] = v0; e->v[1] = v1; e->flist = 0; e->boundary = false; e->next = next; return e; }
static pfaceentry new_faceentry(uint name, pedgeentry e0, pedgeentry e1, pedgeentry e2, pfaceentry next) { pfaceentry f; f = (pfaceentry) allocmem(sizeof(faceentry)); f->name = name; f->e[0] = e0; f->e[1] = e1; f->e[2] = e2; f->neighbours = 0; f->next = next; return f; }
puniform new_uniform(pclusterbasis rb, pclusterbasis cb) { puniform u; u = allocmem(sizeof(uniform)); u->rb = u->cb = 0; u->rnext = u->rprev = u->cnext = u->cprev = 0; ref_row_uniform(u, rb); ref_col_uniform(u, cb); init_amatrix(&u->S, rb->k, cb->k); return u; }