add oversampler
This commit is contained in:
580
oversampling/WDL/eel2/nseel-ram.c
Normal file
580
oversampling/WDL/eel2/nseel-ram.c
Normal file
@@ -0,0 +1,580 @@
|
||||
/*
|
||||
Expression Evaluator Library (NS-EEL) v2
|
||||
Copyright (C) 2004-2013 Cockos Incorporated
|
||||
Copyright (C) 1999-2003 Nullsoft, Inc.
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
#include "ns-eel.h"
|
||||
#include "ns-eel-int.h"
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <malloc.h>
|
||||
#ifdef _MSC_VER
|
||||
#define inline __inline
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
unsigned int NSEEL_RAM_limitmem=0;
|
||||
unsigned int NSEEL_RAM_memused=0;
|
||||
int NSEEL_RAM_memused_errors=0;
|
||||
|
||||
|
||||
|
||||
int NSEEL_VM_wantfreeRAM(NSEEL_VMCTX ctx)
|
||||
{
|
||||
if (ctx)
|
||||
{
|
||||
compileContext *c=(compileContext*)ctx;
|
||||
if (c->ram_state->needfree)
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void NSEEL_VM_freeRAMIfCodeRequested(NSEEL_VMCTX ctx) // check to see if our free flag was set
|
||||
{
|
||||
if (ctx)
|
||||
{
|
||||
compileContext *c=(compileContext*)ctx;
|
||||
if (c->ram_state->needfree)
|
||||
{
|
||||
NSEEL_HOSTSTUB_EnterMutex();
|
||||
{
|
||||
INT_PTR startpos=((INT_PTR)c->ram_state->needfree)-1;
|
||||
EEL_F **blocks = c->ram_state->blocks;
|
||||
INT_PTR pos=0;
|
||||
int x;
|
||||
for (x = 0; x < NSEEL_RAM_BLOCKS; x ++)
|
||||
{
|
||||
if (pos >= startpos)
|
||||
{
|
||||
if (blocks[x])
|
||||
{
|
||||
if (NSEEL_RAM_memused >= sizeof(EEL_F) * NSEEL_RAM_ITEMSPERBLOCK)
|
||||
NSEEL_RAM_memused -= sizeof(EEL_F) * NSEEL_RAM_ITEMSPERBLOCK;
|
||||
else NSEEL_RAM_memused_errors++;
|
||||
free(blocks[x]);
|
||||
blocks[x]=0;
|
||||
}
|
||||
}
|
||||
pos+=NSEEL_RAM_ITEMSPERBLOCK;
|
||||
}
|
||||
c->ram_state->needfree=0;
|
||||
}
|
||||
NSEEL_HOSTSTUB_LeaveMutex();
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
EEL_F nseel_ramalloc_onfail;
|
||||
EEL_F * volatile nseel_gmembuf_default;
|
||||
|
||||
|
||||
void *(*nseel_gmem_calloc)(size_t a, size_t b);
|
||||
|
||||
EEL_F * NSEEL_CGEN_CALL __NSEEL_RAMAllocGMEM(EEL_F ***blocks, unsigned int w)
|
||||
{
|
||||
if (blocks)
|
||||
{
|
||||
EEL_F **pblocks=*blocks;
|
||||
|
||||
if (w < NSEEL_RAM_BLOCKS*NSEEL_RAM_ITEMSPERBLOCK)
|
||||
{
|
||||
const unsigned int whichblock = w/NSEEL_RAM_ITEMSPERBLOCK;
|
||||
EEL_F *p=NULL;
|
||||
if (!pblocks || !(p=pblocks[whichblock]))
|
||||
{
|
||||
NSEEL_HOSTSTUB_EnterMutex();
|
||||
if (!nseel_gmem_calloc) nseel_gmem_calloc=calloc;
|
||||
|
||||
if (!(pblocks=*blocks)) pblocks = *blocks = (EEL_F **)nseel_gmem_calloc(sizeof(EEL_F *),NSEEL_RAM_BLOCKS);
|
||||
else p = pblocks[whichblock];
|
||||
|
||||
if (!p && pblocks)
|
||||
{
|
||||
p=pblocks[whichblock]=(EEL_F *)nseel_gmem_calloc(sizeof(EEL_F),NSEEL_RAM_ITEMSPERBLOCK);
|
||||
}
|
||||
NSEEL_HOSTSTUB_LeaveMutex();
|
||||
}
|
||||
if (p) return p + (w&(NSEEL_RAM_ITEMSPERBLOCK-1));
|
||||
}
|
||||
return &nseel_ramalloc_onfail;
|
||||
}
|
||||
|
||||
if (!nseel_gmembuf_default)
|
||||
{
|
||||
NSEEL_HOSTSTUB_EnterMutex();
|
||||
if (!nseel_gmembuf_default) nseel_gmembuf_default=(EEL_F*)calloc(sizeof(EEL_F),NSEEL_SHARED_GRAM_SIZE);
|
||||
NSEEL_HOSTSTUB_LeaveMutex();
|
||||
if (!nseel_gmembuf_default) return &nseel_ramalloc_onfail;
|
||||
}
|
||||
|
||||
return nseel_gmembuf_default+(((unsigned int)w)&((NSEEL_SHARED_GRAM_SIZE)-1));
|
||||
}
|
||||
|
||||
|
||||
EEL_F * NSEEL_CGEN_CALL __NSEEL_RAMAlloc(EEL_F **pblocks, unsigned int w)
|
||||
{
|
||||
// fprintf(stderr,"got request at %d, %d\n",w/NSEEL_RAM_ITEMSPERBLOCK, w&(NSEEL_RAM_ITEMSPERBLOCK-1));
|
||||
if (w < NSEEL_RAM_BLOCKS*NSEEL_RAM_ITEMSPERBLOCK)
|
||||
{
|
||||
unsigned int whichblock = w/NSEEL_RAM_ITEMSPERBLOCK;
|
||||
EEL_F *p=pblocks[whichblock];
|
||||
if (!p && whichblock < ((unsigned int *)pblocks)[-3]) // pblocks -1/-2 are closefact, -3 is maxblocks
|
||||
{
|
||||
NSEEL_HOSTSTUB_EnterMutex();
|
||||
|
||||
if (!(p=pblocks[whichblock]))
|
||||
{
|
||||
|
||||
const int msize=sizeof(EEL_F) * NSEEL_RAM_ITEMSPERBLOCK;
|
||||
if (!NSEEL_RAM_limitmem || NSEEL_RAM_memused+msize < NSEEL_RAM_limitmem)
|
||||
{
|
||||
p=pblocks[whichblock]=(EEL_F *)calloc(sizeof(EEL_F),NSEEL_RAM_ITEMSPERBLOCK);
|
||||
if (p) NSEEL_RAM_memused+=msize;
|
||||
}
|
||||
}
|
||||
NSEEL_HOSTSTUB_LeaveMutex();
|
||||
}
|
||||
if (p) return p + (w&(NSEEL_RAM_ITEMSPERBLOCK-1));
|
||||
}
|
||||
// fprintf(stderr,"ret 0\n");
|
||||
return &nseel_ramalloc_onfail;
|
||||
}
|
||||
|
||||
|
||||
EEL_F * NSEEL_CGEN_CALL __NSEEL_RAM_MemFree(void *blocks, EEL_F *which)
|
||||
{
|
||||
// blocks points to ram_state->blocks, so back it up past closefact and maxblocks to needfree
|
||||
int *flag = (int *)((char *)blocks - sizeof(double) - 2*sizeof(int));
|
||||
int d=(int)(*which);
|
||||
if (d < 0) d=0;
|
||||
if (d < flag[1]*NSEEL_RAM_ITEMSPERBLOCK) flag[0]=1+d;
|
||||
return which;
|
||||
}
|
||||
|
||||
EEL_F * NSEEL_CGEN_CALL __NSEEL_RAM_MemTop(void *blocks, EEL_F *which)
|
||||
{
|
||||
// blocks points to ram_state->blocks, so back it up past closefact to maxblocks
|
||||
const int *flag = (int *)((char *)blocks - sizeof(double) - sizeof(int));
|
||||
*which = flag[0]*NSEEL_RAM_ITEMSPERBLOCK;
|
||||
return which;
|
||||
}
|
||||
|
||||
|
||||
EEL_F NSEEL_CGEN_CALL __NSEEL_RAM_MemInsertShuffle(EEL_F **blocks,EEL_F *buf, EEL_F *lenptr, EEL_F *value)
|
||||
{
|
||||
int src_offs = (int)*buf;
|
||||
int len = (int)*lenptr;
|
||||
int copy_len;
|
||||
|
||||
EEL_F ret = *value;
|
||||
|
||||
unsigned int sbidx = (unsigned int)src_offs / NSEEL_RAM_ITEMSPERBLOCK;
|
||||
|
||||
if (len < 1 || src_offs < 0) return 0.0;
|
||||
|
||||
src_offs = src_offs&(NSEEL_RAM_ITEMSPERBLOCK-1);
|
||||
copy_len = wdl_min(len,NSEEL_RAM_ITEMSPERBLOCK - src_offs);
|
||||
|
||||
for (;;)
|
||||
{
|
||||
EEL_F *srcptr;
|
||||
if (sbidx >= NSEEL_RAM_BLOCKS) break;
|
||||
|
||||
srcptr = blocks[sbidx];
|
||||
|
||||
if (WDL_unlikely(!srcptr))
|
||||
{
|
||||
srcptr = __NSEEL_RAMAlloc(blocks,sbidx * NSEEL_RAM_ITEMSPERBLOCK);
|
||||
if (srcptr==&nseel_ramalloc_onfail) break;
|
||||
}
|
||||
|
||||
len-=copy_len;
|
||||
srcptr += src_offs;
|
||||
while (copy_len-- > 0)
|
||||
{
|
||||
EEL_F v = *srcptr;
|
||||
*srcptr++ = ret;
|
||||
ret = v;
|
||||
}
|
||||
if (!len) break;
|
||||
|
||||
sbidx++;
|
||||
src_offs=0;
|
||||
copy_len = wdl_min(len,NSEEL_RAM_ITEMSPERBLOCK);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
EEL_F NSEEL_CGEN_CALL __NSEEL_RAM_MemSumProducts(EEL_F **blocks,EEL_F *dest, EEL_F *src, EEL_F *lenptr)
|
||||
{
|
||||
int src_offs = (int)*src;
|
||||
int len = (int)*lenptr;
|
||||
|
||||
EEL_F sum = 0.0;
|
||||
|
||||
if (len < 1 || src_offs < 0) return 0.0;
|
||||
|
||||
if (*dest < 0.0)
|
||||
{
|
||||
int copy_len;
|
||||
unsigned int sbidx = (unsigned int)src_offs / NSEEL_RAM_ITEMSPERBLOCK;
|
||||
src_offs = src_offs&(NSEEL_RAM_ITEMSPERBLOCK-1);
|
||||
copy_len = wdl_min(len,NSEEL_RAM_ITEMSPERBLOCK - src_offs);
|
||||
for (;;)
|
||||
{
|
||||
const EEL_F *srcptr;
|
||||
if (sbidx >= NSEEL_RAM_BLOCKS) break;
|
||||
|
||||
srcptr = blocks[sbidx];
|
||||
|
||||
if (WDL_likely(srcptr))
|
||||
{
|
||||
int i;
|
||||
srcptr += src_offs;
|
||||
if (*dest == -1.0)
|
||||
for (i = 0; i < copy_len; i ++) sum += srcptr[i] * srcptr[i];
|
||||
else if (*dest == -2.0)
|
||||
for (i = 0; i < copy_len; i ++) sum += fabs(srcptr[i]);
|
||||
else
|
||||
for (i = 0; i < copy_len; i ++) sum += srcptr[i];
|
||||
}
|
||||
len-=copy_len;
|
||||
if (!len) break;
|
||||
|
||||
sbidx++;
|
||||
src_offs=0;
|
||||
copy_len = wdl_min(len,NSEEL_RAM_ITEMSPERBLOCK);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
unsigned int dest_offs = (unsigned int) (int)*dest;
|
||||
for (;;)
|
||||
{
|
||||
unsigned int sbidx = (unsigned int)src_offs / NSEEL_RAM_ITEMSPERBLOCK;
|
||||
const int sbo = (src_offs&(NSEEL_RAM_ITEMSPERBLOCK-1));
|
||||
unsigned int dbidx = dest_offs / NSEEL_RAM_ITEMSPERBLOCK;
|
||||
const int dbo = (dest_offs&(NSEEL_RAM_ITEMSPERBLOCK-1));
|
||||
|
||||
const int copy_len = wdl_min(len,NSEEL_RAM_ITEMSPERBLOCK - wdl_max(dbo,sbo));
|
||||
|
||||
const EEL_F *srcptr, *destptr;
|
||||
|
||||
if (sbidx >= NSEEL_RAM_BLOCKS || dbidx >= NSEEL_RAM_BLOCKS) break;
|
||||
srcptr = blocks[sbidx];
|
||||
destptr = blocks[dbidx];
|
||||
if (WDL_likely(srcptr && destptr))
|
||||
{
|
||||
int i;
|
||||
srcptr += sbo;
|
||||
destptr += dbo;
|
||||
for (i = 0; i < copy_len; i ++) sum += destptr[i] * srcptr[i];
|
||||
}
|
||||
len-=copy_len;
|
||||
if (!len) break;
|
||||
|
||||
src_offs += copy_len;
|
||||
dest_offs += copy_len;
|
||||
}
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
|
||||
EEL_F * NSEEL_CGEN_CALL __NSEEL_RAM_MemCpy(EEL_F **blocks,EEL_F *dest, EEL_F *src, EEL_F *lenptr)
|
||||
{
|
||||
const int mem_size=NSEEL_RAM_BLOCKS*NSEEL_RAM_ITEMSPERBLOCK;
|
||||
int dest_offs = (int)(*dest + 0.0001);
|
||||
int src_offs = (int)(*src + 0.0001);
|
||||
int len = (int)(*lenptr + 0.0001);
|
||||
int want_mmove=0;
|
||||
|
||||
// trim to front
|
||||
if (src_offs<0)
|
||||
{
|
||||
len += src_offs;
|
||||
dest_offs -= src_offs;
|
||||
src_offs=0;
|
||||
}
|
||||
if (dest_offs<0)
|
||||
{
|
||||
len += dest_offs;
|
||||
src_offs -= dest_offs;
|
||||
dest_offs=0;
|
||||
}
|
||||
if (src_offs + len > mem_size) len = mem_size-src_offs;
|
||||
if (dest_offs + len > mem_size) len = mem_size-dest_offs;
|
||||
|
||||
if (src_offs == dest_offs || len < 1) return dest;
|
||||
|
||||
if (src_offs < dest_offs && src_offs+len > dest_offs)
|
||||
{
|
||||
// if src_offs < dest_offs and overlapping, must copy right to left
|
||||
if ((dest_offs - src_offs) < NSEEL_RAM_ITEMSPERBLOCK) want_mmove = 1;
|
||||
src_offs += len;
|
||||
dest_offs += len;
|
||||
while (len > 0)
|
||||
{
|
||||
const int maxdlen=((dest_offs-1)&(NSEEL_RAM_ITEMSPERBLOCK-1)) + 1;
|
||||
const int maxslen=((src_offs-1)&(NSEEL_RAM_ITEMSPERBLOCK-1)) + 1;
|
||||
int copy_len = len;
|
||||
EEL_F *srcptr,*destptr;
|
||||
|
||||
if (copy_len > maxdlen) copy_len=maxdlen;
|
||||
if (copy_len > maxslen) copy_len=maxslen;
|
||||
|
||||
srcptr = __NSEEL_RAMAlloc(blocks,src_offs - copy_len);
|
||||
destptr = __NSEEL_RAMAlloc(blocks,dest_offs - copy_len);
|
||||
if (srcptr==&nseel_ramalloc_onfail || destptr==&nseel_ramalloc_onfail) break;
|
||||
|
||||
if (want_mmove) memmove(destptr,srcptr,sizeof(EEL_F)*copy_len);
|
||||
else memcpy(destptr,srcptr,sizeof(EEL_F)*copy_len);
|
||||
src_offs-=copy_len;
|
||||
dest_offs-=copy_len;
|
||||
len-=copy_len;
|
||||
}
|
||||
return dest;
|
||||
}
|
||||
|
||||
if (dest_offs < src_offs && dest_offs+len > src_offs)
|
||||
{
|
||||
// if dest_offs < src_offs and overlapping, and less than NSEEL_RAM_ITEMSPERBLOCK apart, use memmove()
|
||||
if ((src_offs-dest_offs) < NSEEL_RAM_ITEMSPERBLOCK) want_mmove = 1;
|
||||
}
|
||||
|
||||
while (len > 0)
|
||||
{
|
||||
const int maxdlen=NSEEL_RAM_ITEMSPERBLOCK - (dest_offs&(NSEEL_RAM_ITEMSPERBLOCK-1));
|
||||
const int maxslen=NSEEL_RAM_ITEMSPERBLOCK - (src_offs&(NSEEL_RAM_ITEMSPERBLOCK-1));
|
||||
int copy_len = len;
|
||||
EEL_F *srcptr,*destptr;
|
||||
|
||||
if (copy_len > maxdlen) copy_len=maxdlen;
|
||||
if (copy_len > maxslen) copy_len=maxslen;
|
||||
|
||||
srcptr = __NSEEL_RAMAlloc(blocks,src_offs);
|
||||
destptr = __NSEEL_RAMAlloc(blocks,dest_offs);
|
||||
if (srcptr==&nseel_ramalloc_onfail || destptr==&nseel_ramalloc_onfail) break;
|
||||
|
||||
if (want_mmove) memmove(destptr,srcptr,sizeof(EEL_F)*copy_len);
|
||||
else memcpy(destptr,srcptr,sizeof(EEL_F)*copy_len);
|
||||
src_offs+=copy_len;
|
||||
dest_offs+=copy_len;
|
||||
len-=copy_len;
|
||||
}
|
||||
return dest;
|
||||
}
|
||||
|
||||
EEL_F * NSEEL_CGEN_CALL __NSEEL_RAM_MemSet(EEL_F **blocks,EEL_F *dest, EEL_F *v, EEL_F *lenptr)
|
||||
{
|
||||
int offs = (int)(*dest + 0.0001);
|
||||
int len = (int)(*lenptr + 0.0001);
|
||||
EEL_F t;
|
||||
if (offs<0)
|
||||
{
|
||||
len += offs;
|
||||
offs=0;
|
||||
}
|
||||
if (offs >= NSEEL_RAM_BLOCKS*NSEEL_RAM_ITEMSPERBLOCK) return dest;
|
||||
|
||||
if (offs+len > NSEEL_RAM_BLOCKS*NSEEL_RAM_ITEMSPERBLOCK) len = NSEEL_RAM_BLOCKS*NSEEL_RAM_ITEMSPERBLOCK - offs;
|
||||
|
||||
if (len < 1) return dest;
|
||||
|
||||
|
||||
t=*v; // set value
|
||||
|
||||
// int lastBlock=-1;
|
||||
while (len > 0)
|
||||
{
|
||||
int lcnt;
|
||||
EEL_F *ptr=__NSEEL_RAMAlloc(blocks,offs);
|
||||
if (ptr==&nseel_ramalloc_onfail) break;
|
||||
|
||||
lcnt=NSEEL_RAM_ITEMSPERBLOCK-(offs&(NSEEL_RAM_ITEMSPERBLOCK-1));
|
||||
if (lcnt > len) lcnt=len;
|
||||
|
||||
len -= lcnt;
|
||||
offs += lcnt;
|
||||
|
||||
while (lcnt--)
|
||||
{
|
||||
*ptr++=t;
|
||||
}
|
||||
}
|
||||
return dest;
|
||||
}
|
||||
|
||||
|
||||
static inline int __getset_values(EEL_F **blocks, int isset, int len, EEL_F **parms)
|
||||
{
|
||||
int offs, lout=0;
|
||||
unsigned int pageidx, sub_offs;
|
||||
if (--len < 1) return 0;
|
||||
offs = (int)(parms++[0][0] + 0.0001);
|
||||
|
||||
if (offs<=0)
|
||||
{
|
||||
len += offs;
|
||||
parms -= offs;
|
||||
offs=0;
|
||||
pageidx=sub_offs=0;
|
||||
if (len<1) return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
sub_offs = ((unsigned int)offs) & (NSEEL_RAM_ITEMSPERBLOCK-1);
|
||||
pageidx = ((unsigned int)offs)>>NSEEL_RAM_ITEMSPERBLOCK_LOG2;
|
||||
if (pageidx>=NSEEL_RAM_BLOCKS) return 0;
|
||||
}
|
||||
|
||||
for (;;)
|
||||
{
|
||||
int lcnt=NSEEL_RAM_ITEMSPERBLOCK-sub_offs;
|
||||
EEL_F *ptr=blocks[pageidx];
|
||||
if (!ptr)
|
||||
{
|
||||
ptr = __NSEEL_RAMAlloc(blocks,offs + lout);
|
||||
if (ptr==&nseel_ramalloc_onfail) return lout;
|
||||
}
|
||||
else
|
||||
{
|
||||
ptr += sub_offs;
|
||||
}
|
||||
|
||||
if (lcnt >= len)
|
||||
{
|
||||
// this page satisfies the request (normal behavior)
|
||||
lout += len;
|
||||
if (isset) while (len--) *ptr++=parms++[0][0];
|
||||
else while (len--) parms++[0][0] = *ptr++;
|
||||
return lout;
|
||||
}
|
||||
|
||||
// crossing a page boundary
|
||||
len -= lcnt;
|
||||
lout += lcnt;
|
||||
if (isset) while (lcnt--) *ptr++=parms++[0][0];
|
||||
else while (lcnt--) parms++[0][0] = *ptr++;
|
||||
|
||||
if (len <= 0 || ++pageidx >= NSEEL_RAM_BLOCKS) return lout;
|
||||
sub_offs=0;
|
||||
}
|
||||
}
|
||||
|
||||
EEL_F NSEEL_CGEN_CALL __NSEEL_RAM_Mem_SetValues(EEL_F **blocks, INT_PTR np, EEL_F **parms)
|
||||
{
|
||||
return __getset_values(blocks,1,(int)np,parms);
|
||||
}
|
||||
|
||||
EEL_F NSEEL_CGEN_CALL __NSEEL_RAM_Mem_GetValues(EEL_F **blocks, INT_PTR np, EEL_F **parms)
|
||||
{
|
||||
return __getset_values(blocks,0,(int)np,parms);
|
||||
}
|
||||
|
||||
void NSEEL_VM_SetGRAM(NSEEL_VMCTX ctx, void **gram)
|
||||
{
|
||||
if (ctx)
|
||||
{
|
||||
compileContext *c=(compileContext*)ctx;
|
||||
c->gram_blocks = gram;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void NSEEL_VM_freeRAM(NSEEL_VMCTX ctx)
|
||||
{
|
||||
if (ctx)
|
||||
{
|
||||
int x;
|
||||
compileContext *c=(compileContext*)ctx;
|
||||
EEL_F **blocks = c->ram_state->blocks;
|
||||
for (x = 0; x < NSEEL_RAM_BLOCKS; x ++)
|
||||
{
|
||||
if (blocks[x])
|
||||
{
|
||||
if (NSEEL_RAM_memused >= sizeof(EEL_F) * NSEEL_RAM_ITEMSPERBLOCK)
|
||||
NSEEL_RAM_memused -= sizeof(EEL_F) * NSEEL_RAM_ITEMSPERBLOCK;
|
||||
else NSEEL_RAM_memused_errors++;
|
||||
free(blocks[x]);
|
||||
blocks[x]=0;
|
||||
}
|
||||
}
|
||||
c->ram_state->needfree=0; // no need to free anymore
|
||||
}
|
||||
}
|
||||
|
||||
void NSEEL_VM_FreeGRAM(void **ufd)
|
||||
{
|
||||
if (ufd[0])
|
||||
{
|
||||
EEL_F **blocks = (EEL_F **)ufd[0];
|
||||
int x;
|
||||
for (x = 0; x < NSEEL_RAM_BLOCKS; x ++)
|
||||
{
|
||||
if (blocks[x])
|
||||
{
|
||||
if (NSEEL_RAM_memused >= sizeof(EEL_F) * NSEEL_RAM_ITEMSPERBLOCK)
|
||||
NSEEL_RAM_memused -= sizeof(EEL_F) * NSEEL_RAM_ITEMSPERBLOCK;
|
||||
else NSEEL_RAM_memused_errors++;
|
||||
}
|
||||
free(blocks[x]);
|
||||
blocks[x]=0;
|
||||
}
|
||||
free(blocks);
|
||||
ufd[0]=0;
|
||||
}
|
||||
}
|
||||
|
||||
EEL_F *NSEEL_VM_getramptr(NSEEL_VMCTX ctx, unsigned int offs, int *validCount)
|
||||
{
|
||||
EEL_F *d=__NSEEL_RAMAlloc(ctx ? ((compileContext*)ctx)->ram_state->blocks : 0,offs);
|
||||
if (!d || d == &nseel_ramalloc_onfail) return NULL;
|
||||
if (validCount) *validCount = NSEEL_RAM_ITEMSPERBLOCK - (offs%NSEEL_RAM_ITEMSPERBLOCK);
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
EEL_F *NSEEL_VM_getramptr_noalloc(NSEEL_VMCTX ctx, unsigned int offs, int *validCount)
|
||||
{
|
||||
EEL_F *d;
|
||||
compileContext *cc = (compileContext *)ctx;
|
||||
|
||||
if (!cc ||
|
||||
offs >= NSEEL_RAM_ITEMSPERBLOCK*NSEEL_RAM_BLOCKS ||
|
||||
NULL == (d = cc->ram_state->blocks[offs/NSEEL_RAM_ITEMSPERBLOCK])
|
||||
)
|
||||
{
|
||||
if (validCount) *validCount = 0;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
offs %= NSEEL_RAM_ITEMSPERBLOCK;
|
||||
if (validCount) *validCount = NSEEL_RAM_ITEMSPERBLOCK - offs;
|
||||
return d + offs;
|
||||
}
|
||||
Reference in New Issue
Block a user