示例#1
0
void fcache_terminate(fcache_context * pfcache)
{
    dprintverbose("start fcache_terminate");

    if(pfcache != NULL)
    {
        if(pfcache->header != NULL)
        {
            InterlockedDecrement(&pfcache->header->mapcount);
            pfcache->header = NULL;
        }

        if(pfcache->palloc != NULL)
        {
            alloc_terminate(pfcache->palloc);
            alloc_destroy(pfcache->palloc);

            pfcache->palloc = NULL;
        }

        if(pfcache->pfilemap != NULL)
        {
            filemap_terminate(pfcache->pfilemap);
            filemap_destroy(pfcache->pfilemap);

            pfcache->pfilemap = NULL;
        }

        if(pfcache->prwlock != NULL)
        {
            lock_terminate(pfcache->prwlock);
            lock_destroy(pfcache->prwlock);

            pfcache->prwlock = NULL;
        }

        if(pfcache->hinitdone != NULL)
        {
            CloseHandle(pfcache->hinitdone);
            pfcache->hinitdone = NULL;
        }
    }

    dprintverbose("end fcache_terminate");

    return;
}
示例#2
0
static void sabrelite_destructor(QOSGraphObject *obj)
{
    QSabreliteMachine *machine = (QSabreliteMachine *) obj;
    alloc_destroy(&machine->alloc);
}
示例#3
0
int fcache_initialize(fcache_context * pfcache, unsigned short islocal, unsigned short cachekey, unsigned int cachesize, unsigned int maxfsize TSRMLS_DC)
{
    int             result   = NONFATAL;
    size_t          size     = 0;
    fcache_header * header   = NULL;
    unsigned short  mapclass = FILEMAP_MAP_SRANDOM;
    unsigned short  locktype = LOCK_TYPE_SHARED;
    unsigned char   isfirst  = 1;
    char            evtname[   MAX_PATH];

    dprintverbose("start fcache_initialize");

    _ASSERT(pfcache   != NULL);
    _ASSERT(cachekey  != 0);
    _ASSERT(cachesize >= FCACHE_SIZE_MINIMUM && cachesize <= FCACHE_SIZE_MAXIMUM);
    _ASSERT(maxfsize  >= FILE_SIZE_MINIMUM   && maxfsize  <= FILE_SIZE_MAXIMUM);

    /* Initialize memory map to store code files */
    result = filemap_create(&pfcache->pfilemap);
    if(FAILED(result))
    {
        goto Finished;
    }

    pfcache->cachekey = cachekey;

    if(islocal)
    {
        mapclass = FILEMAP_MAP_LRANDOM;
        locktype = LOCK_TYPE_LOCAL;

        pfcache->islocal = islocal;
    }

    /* shmfilepath = NULL to use page file for shared memory */
    result = filemap_initialize(pfcache->pfilemap, FILEMAP_TYPE_FILECONTENT, cachekey, mapclass, cachesize, NULL TSRMLS_CC);
    if(FAILED(result))
    {
        goto Finished;
    }

    pfcache->memaddr = (char *)pfcache->pfilemap->mapaddr;
    size = filemap_getsize(pfcache->pfilemap TSRMLS_CC);

    /* Create allocator for filecache segment */
    result = alloc_create(&pfcache->palloc);
    if(FAILED(result))
    {
        goto Finished;
    }

    /* initmemory = 1 for all page file backed shared memory allocators */
    result = alloc_initialize(pfcache->palloc, islocal, "FILECONTENT_SEGMENT", cachekey, pfcache->memaddr, size, 1 TSRMLS_CC);
    if(FAILED(result))
    {
        goto Finished;
    }

    /* Get memory for cache header */
    pfcache->header = (fcache_header *)alloc_get_cacheheader(pfcache->palloc, sizeof(fcache_header), CACHE_TYPE_FILECONTENT);
    if(pfcache->header == NULL)
    {
        result = FATAL_FCACHE_INITIALIZE;
        goto Finished;
    }

    header = pfcache->header;

    /* Create xread xwrite lock for the filecache */
    result = lock_create(&pfcache->prwlock);
    if(FAILED(result))
    {
        goto Finished;
    }

    result = lock_initialize(pfcache->prwlock, "FILECONTENT_CACHE", cachekey, locktype, LOCK_USET_XREAD_XWRITE, NULL TSRMLS_CC);
    if(FAILED(result))
    {
        goto Finished;
    }

    result = lock_getnewname(pfcache->prwlock, "FCACHE_INIT", evtname, MAX_PATH);
    if(FAILED(result))
    {
        goto Finished;
    }

    pfcache->hinitdone = CreateEvent(NULL, TRUE, FALSE, evtname);
    if(pfcache->hinitdone == NULL)
    {
        result = FATAL_FCACHE_INIT_EVENT;
        goto Finished;
    }

    if(GetLastError() == ERROR_ALREADY_EXISTS)
    {
        _ASSERT(islocal == 0);
        isfirst = 0;

        /* Wait for other process to initialize completely */
        WaitForSingleObject(pfcache->hinitdone, INFINITE);
    }

    /* Initialize the fcache_header if its not initialized already */
    if(islocal || isfirst)
    {
        lock_writelock(pfcache->prwlock);

        header->mapcount    = 1;
        header->itemcount   = 0;
        header->hitcount    = 0;
        header->misscount   = 0;

        SetEvent(pfcache->hinitdone);
        
        lock_writeunlock(pfcache->prwlock);
    }
    else
    {
        /* Increment the mapcount */
        InterlockedIncrement(&header->mapcount);
    }

    /* Keep maxfsize in fcache_context */
    pfcache->maxfsize = maxfsize * 1024;

Finished:

    if(FAILED(result))
    {
        dprintimportant("failure %d in fcache_initialize", result);
        _ASSERT(result > WARNING_COMMON_BASE);

        if(pfcache->palloc != NULL)
        {
            alloc_terminate(pfcache->palloc);
            alloc_destroy(pfcache->palloc);

            pfcache->palloc = NULL;
        }

        if(pfcache->pfilemap != NULL)
        {
            filemap_terminate(pfcache->pfilemap);
            filemap_destroy(pfcache->pfilemap);

            pfcache->pfilemap = NULL;
        }

        if(pfcache->prwlock != NULL)
        {
            lock_terminate(pfcache->prwlock);
            lock_destroy(pfcache->prwlock);

            pfcache->prwlock = NULL;
        }

        if(pfcache->hinitdone != NULL)
        {
            CloseHandle(pfcache->hinitdone);
            pfcache->hinitdone = NULL;
        }
    }

    dprintverbose("end fcache_initialize");

    return result;
}
示例#4
0
static void virt_destructor(QOSGraphObject *obj)
{
    QVirtMachine *machine = (QVirtMachine *) obj;
    alloc_destroy(&machine->alloc);
}