358 lines
6.1 KiB
C++
Executable File
358 lines
6.1 KiB
C++
Executable File
// handle-based resource manager
|
|
//
|
|
// Copyright (c) 2003 Jan Wassenberg
|
|
//
|
|
// This program is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU General Public License as
|
|
// published by the Free Software Foundation; either version 2 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful, but
|
|
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// General Public License for more details.
|
|
//
|
|
// Contact info:
|
|
// Jan.Wassenberg@stud.uni-karlsruhe.de
|
|
// http://www.stud.uni-karlsruhe.de/~urkt/
|
|
|
|
#include <cassert>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <cstdio>
|
|
|
|
#include "types.h"
|
|
#include "unzip.h"
|
|
#include "posix.h"
|
|
#include "misc.h"
|
|
#include "res.h"
|
|
#include "vfs.h"
|
|
|
|
// handle (32 bits)
|
|
// .. make sure this is the same handle we opened
|
|
static const uint TAG_BITS = 16;
|
|
// .. index into array => = log2(max open handles)
|
|
static const uint IDX_BITS = 12;
|
|
|
|
static const uint OWNER_BITS = 4;
|
|
static const uint TYPE_BITS = 4;
|
|
static const uint REF_BITS = 8;
|
|
|
|
struct Res
|
|
{
|
|
u32 key;
|
|
u32 tag : TAG_BITS;
|
|
u32 type : TYPE_BITS;
|
|
u32 owner : OWNER_BITS;
|
|
u32 refs : REF_BITS;
|
|
};
|
|
|
|
static const ulong res_array_cap = 1ul << IDX_BITS;
|
|
static const uint owner_cap = 1ul << OWNER_BITS;
|
|
|
|
// static allocation for simplicity; mem usage isn't significant
|
|
static Res res_array[res_array_cap];
|
|
static int first_free = -1;
|
|
static int max_idx = -1; // index of last in-use entry
|
|
|
|
// array of pages for better locality, less fragmentation
|
|
static const uint PAGE_SIZE = 4096;
|
|
static const uint hdata_per_page = PAGE_SIZE / sizeof(HDATA);
|
|
static const uint num_pages = res_array_cap / hdata_per_page;
|
|
static HDATA* pages[num_pages];
|
|
|
|
static void(*dtors[owner_cap])(HDATA*);
|
|
|
|
|
|
|
|
static Handle handle(const int idx)
|
|
{
|
|
const Res& r = res_array[idx];
|
|
return (r.tag) << IDX_BITS | (u32)idx;
|
|
}
|
|
|
|
|
|
static int h_idx(const Handle h, const uint owner)
|
|
{
|
|
int idx = h & ((1 << IDX_BITS)-1);
|
|
const Res& r = res_array[idx];
|
|
|
|
u32 tag = h >> IDX_BITS;
|
|
if(!tag || r.tag != tag || r.owner != owner)
|
|
return -1;
|
|
|
|
return idx;
|
|
}
|
|
|
|
|
|
static HDATA* h_data(const int idx)
|
|
{
|
|
HDATA*& page = pages[idx / hdata_per_page];
|
|
if(!page)
|
|
{
|
|
page = (HDATA*)calloc(PAGE_SIZE, 1);
|
|
if(!page)
|
|
return 0;
|
|
}
|
|
|
|
return &page[idx % hdata_per_page];
|
|
}
|
|
|
|
|
|
static int h_free(const int idx)
|
|
{
|
|
Res& r = res_array[idx];
|
|
if(--r.refs)
|
|
return 0;
|
|
|
|
HDATA* hd = h_data(idx);
|
|
if(hd)
|
|
{
|
|
if(dtors[r.owner])
|
|
dtors[r.owner](hd);
|
|
memset(hd, 0, sizeof(HDATA));
|
|
}
|
|
|
|
memset(&r, 0, sizeof(r));
|
|
|
|
if(first_free == -1 || idx < first_free)
|
|
first_free = idx;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void cleanup(void)
|
|
{
|
|
int i;
|
|
|
|
// close open handles
|
|
for(i = 0; i < max_idx; i++)
|
|
h_free(i);
|
|
|
|
// free internal data space
|
|
for(i = 0; i < (int)num_pages; i++)
|
|
{
|
|
free(pages[i]);
|
|
pages[i] = 0;
|
|
}
|
|
}
|
|
|
|
|
|
Handle h_find(const void* p, uint owner, HDATA** phd)
|
|
{
|
|
const Res* r = res_array;
|
|
|
|
for(int idx = 0; idx <= max_idx; idx++, r++)
|
|
{
|
|
if(r->owner != owner)
|
|
continue;
|
|
|
|
HDATA* hd = h_data(idx);
|
|
if(hd && hd->p == p)
|
|
{
|
|
if(phd)
|
|
*phd = hd;
|
|
return handle(idx);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
Handle h_find(const u32 key, uint owner, HDATA** phd)
|
|
{
|
|
int idx;
|
|
const Res* r = res_array;
|
|
|
|
// already have first free entry cached - just search
|
|
if(first_free != -1)
|
|
{
|
|
for(idx = 0; idx <= max_idx; idx++, r++)
|
|
if(r->key == key && r->owner == owner)
|
|
goto found;
|
|
}
|
|
// search and remember first free entry (slower)
|
|
else
|
|
{
|
|
for(idx = 0; idx <= max_idx; idx++, r++)
|
|
if(!r->tag && first_free == -1)
|
|
first_free = idx;
|
|
else if(r->key == key && r->owner == owner)
|
|
goto found;
|
|
}
|
|
|
|
// not found
|
|
return 0;
|
|
|
|
found:
|
|
Handle h = handle(idx);
|
|
if(phd)
|
|
{
|
|
HDATA* hd = h_data(h, owner);
|
|
if(!hd)
|
|
return 0;
|
|
*phd = hd;
|
|
}
|
|
return h;
|
|
}
|
|
|
|
|
|
Handle h_alloc(const u32 key, const uint owner, DTOR dtor, HDATA** phd)
|
|
{
|
|
ONCE(atexit(cleanup))
|
|
|
|
if(owner >= owner_cap)
|
|
return 0;
|
|
|
|
if(dtor)
|
|
{
|
|
// registering a second dtor for owner
|
|
// if(dtors[owner] && dtors[owner] != dtor)
|
|
// return 0;
|
|
dtors[owner] = dtor;
|
|
}
|
|
|
|
int idx;
|
|
Res* r = res_array;
|
|
|
|
HDATA* hd;
|
|
Handle h;
|
|
if(key)
|
|
{
|
|
h = h_find(key, owner, &hd);
|
|
if(h)
|
|
{
|
|
idx = h_idx(h, owner);
|
|
r = &res_array[idx];
|
|
|
|
assert(hd->size != 0);
|
|
|
|
if(r->refs == (1ul << REF_BITS))
|
|
{
|
|
assert(!"h_alloc: too many references to a handle - increase REF_BITS");
|
|
return 0;
|
|
}
|
|
r->refs++;
|
|
|
|
return h;
|
|
}
|
|
}
|
|
|
|
// cached
|
|
if(first_free != -1)
|
|
{
|
|
idx = first_free;
|
|
r = &res_array[idx];
|
|
}
|
|
// search res_array for first entry
|
|
else
|
|
for(idx = 0; idx < res_array_cap; idx++, r++)
|
|
if(!r->tag)
|
|
break;
|
|
|
|
// check if next entry is free
|
|
if(idx+1 < res_array_cap && !(r+1)->key)
|
|
first_free = idx+1;
|
|
else
|
|
first_free = -1;
|
|
|
|
if(idx >= res_array_cap)
|
|
{
|
|
assert(!"h_alloc: too many open handles (increase IDX_BITS)");
|
|
return 0;
|
|
}
|
|
|
|
if(idx > max_idx)
|
|
max_idx = idx;
|
|
|
|
static u32 tag;
|
|
if(++tag >= (1 << TAG_BITS))
|
|
{
|
|
assert(!"h_alloc: tag overflow - may not notice stale handle reuse (increase TAG_BITS)");
|
|
tag = 1;
|
|
}
|
|
|
|
r->key = key;
|
|
r->tag = tag;
|
|
r->owner = owner;
|
|
|
|
h = handle(idx);
|
|
|
|
// caller wants HDATA* returned
|
|
if(phd)
|
|
{
|
|
HDATA* hd = h_data(h, owner);
|
|
// not enough mem - fail
|
|
if(!hd)
|
|
{
|
|
h_free(h, owner);
|
|
return 0;
|
|
}
|
|
*phd = hd;
|
|
}
|
|
|
|
return h;
|
|
}
|
|
|
|
|
|
int h_free(const Handle h, const uint owner)
|
|
{
|
|
int idx = h_idx(h, owner);
|
|
if(idx >= 0)
|
|
return h_free(idx);
|
|
return -1;
|
|
}
|
|
|
|
|
|
|
|
HDATA* h_data(const Handle h, const uint owner)
|
|
{
|
|
int idx = h_idx(h, owner);
|
|
if(idx >= 0)
|
|
return h_data(idx);
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
Handle res_load(const char* fn, uint type, DTOR dtor, void*& p, size_t& size, HDATA*& hd)
|
|
{
|
|
p = 0;
|
|
size = 0;
|
|
hd = 0;
|
|
|
|
u32 fn_hash = fnv_hash(fn, strlen(fn));
|
|
// TODO: fn is usually a constant; pass fn len if too slow
|
|
|
|
Handle h = h_alloc(fn_hash, type, dtor, &hd);
|
|
if(!h)
|
|
return 0;
|
|
|
|
// already open - return a reference
|
|
if(hd->size)
|
|
return h;
|
|
|
|
Handle hf = vfs_open(fn);
|
|
int err = vfs_read(hf, p, size, 0);
|
|
vfs_close(hf);
|
|
if(err < 0)
|
|
return 0;
|
|
|
|
if(!p)
|
|
{
|
|
h_free(h, type);
|
|
return 0;
|
|
}
|
|
|
|
hd->p = p;
|
|
hd->size = size;
|
|
|
|
return h;
|
|
}
|
|
|
|
|
|
|
|
|