void player_move_to_spawn()
{
dvec3_t p = game.player.pos;
while (blocktype(p.x, p.y-2, p.z) != BLOCK_AIR ||
blocktype(p.x, p.y-1, p.z) != BLOCK_AIR ||
blocktype(p.x, p.y, p.z) != BLOCK_AIR ||
blocktype(p.x + 1, p.y, p.z) != BLOCK_AIR ||
blocktype(p.x - 1, p.y, p.z) != BLOCK_AIR ||
blocktype(p.x, p.y, p.z + 1) != BLOCK_AIR ||
blocktype(p.x, p.y, p.z - 1) != BLOCK_AIR)
p.y += 1.0;
game.player.pos = p;
}
static
void *
subpage_kmalloc(size_t sz)
{
unsigned blktype; // index into sizes[] that we're using
struct pageref *pr; // pageref for page we're allocating from
vaddr_t prpage; // PR_PAGEADDR(pr)
vaddr_t fla; // free list entry address
struct freelist *volatile fl; // free list entry
void *retptr; // our result
volatile int i;
blktype = blocktype(sz);
sz = sizes[blktype];
spinlock_acquire(&kmalloc_spinlock);
checksubpages();
for (pr = sizebases[blktype]; pr != NULL; pr = pr->next_samesize) {
/* check for corruption */
KASSERT(PR_BLOCKTYPE(pr) == blktype);
checksubpage(pr);
if (pr->nfree > 0) {
doalloc: /* comes here after getting a whole fresh page */
KASSERT(pr->freelist_offset < PAGE_SIZE);
prpage = PR_PAGEADDR(pr);
fla = prpage + pr->freelist_offset;
fl = (struct freelist *)fla;
retptr = fl;
fl = fl->next;
pr->nfree--;
if (fl != NULL) {
KASSERT(pr->nfree > 0);
fla = (vaddr_t)fl;
KASSERT(fla - prpage < PAGE_SIZE);
pr->freelist_offset = fla - prpage;
}
else {
KASSERT(pr->nfree == 0);
pr->freelist_offset = INVALID_OFFSET;
}
checksubpages();
spinlock_release(&kmalloc_spinlock);
return retptr;
}
}
/*
* No page of the right size available.
* Make a new one.
*
* We release the spinlock while calling alloc_kpages. This
* avoids deadlock if alloc_kpages needs to come back here.
* Note that this means things can change behind our back...
*/
spinlock_release(&kmalloc_spinlock);
prpage = alloc_kpages(1);
if (prpage==0) {
/* Out of memory. */
kprintf("kmalloc: Subpage allocator couldn't get a page\n");
return NULL;
}
spinlock_acquire(&kmalloc_spinlock);
pr = allocpageref();
if (pr==NULL) {
/* Couldn't allocate accounting space for the new page. */
spinlock_release(&kmalloc_spinlock);
free_kpages(prpage);
kprintf("kmalloc: Subpage allocator couldn't get pageref\n");
return NULL;
}
pr->pageaddr_and_blocktype = MKPAB(prpage, blktype);
pr->nfree = PAGE_SIZE / sizes[blktype];
/*
* Note: fl is volatile because the MIPS toolchain we were
* using in spring 2001 attempted to optimize this loop and
* blew it. Making fl volatile inhibits the optimization.
*/
fla = prpage;
fl = (struct freelist *)fla;
fl->next = NULL;
for (i=1; i<pr->nfree; i++) {
fl = (struct freelist *)(fla + i*sizes[blktype]);
fl->next = (struct freelist *)(fla + (i-1)*sizes[blktype]);
KASSERT(fl != fl->next);
}
fla = (vaddr_t) fl;
pr->freelist_offset = fla - prpage;
KASSERT(pr->freelist_offset == (pr->nfree-1)*sizes[blktype]);
pr->next_samesize = sizebases[blktype];
sizebases[blktype] = pr;
pr->next_all = allbase;
allbase = pr;
/* This is kind of cheesy, but avoids duplicating the alloc code. */
goto doalloc;
}
int main( int argc, const char* argv[])
{
strus::local_ptr<strus::ErrorBufferInterface> errorBuffer( strus::createErrorBuffer_standard( 0, 2, NULL/*debug trace interface*/));
if (!errorBuffer.get())
{
std::cerr << _TXT("failed to create error buffer") << std::endl;
return -1;
}
g_errorBuffer = errorBuffer.get();
try
{
bool doExit = false;
int argi = 1;
unsigned int transactionsize = 1000;
std::pair<unsigned int,unsigned int> docnorange(0,0);
std::string termtype;
// Parsing arguments:
for (; argi < argc; ++argi)
{
if (0==std::strcmp( argv[argi], "-h") || 0==std::strcmp( argv[argi], "--help"))
{
printUsage();
doExit = true;
}
else if (0==std::strcmp( argv[argi], "-v") || 0==std::strcmp( argv[argi], "--version"))
{
std::cerr << "strus storage version " << STRUS_STORAGE_VERSION_STRING << std::endl;
doExit = true;
}
else if (0==std::strcmp( argv[argi], "-c") || 0==std::strcmp( argv[argi], "--commit"))
{
if (argi == argc || argv[argi+1][0] == '-')
{
throw strus::runtime_error( _TXT("no argument given to option %s"), "--commit");
}
++argi;
transactionsize = parseNumber( argv[argi], "argument for option --commit");
}
else if (0==std::strcmp( argv[argi], "-D") || 0==std::strcmp( argv[argi], "--docno"))
{
if (argi == argc || argv[argi+1][0] == '-')
{
throw strus::runtime_error( _TXT("no argument given to option %s"), "--docno");
}
++argi;
docnorange = parseNumberRange( argv[argi], "argument for option --docno");
}
else if (0==std::strcmp( argv[argi], "-T") || 0==std::strcmp( argv[argi], "--termtype"))
{
if (argi == argc || argv[argi+1][0] == '-')
{
throw strus::runtime_error( _TXT("no argument given to option %s"), "--termtype");
}
++argi;
termtype = argv[ argi];
}
else if (argv[argi][0] == '-')
{
throw strus::runtime_error(_TXT("unknown option %s"), argv[ argi]);
}
else
{
break;
}
}
if (doExit) return 0;
if (argc - argi < 3) throw strus::runtime_error( _TXT("too few arguments (given %u, required %u)"), argc - argi, 3);
if (argc - argi > 3) throw strus::runtime_error( _TXT("too many arguments (given %u, required %u)"), argc - argi, 3);
std::string dbconfig( argv[ argi+0]);
std::string blocktype( argv[ argi+1]);
unsigned int newblocksize = parseNumber( argv[argi+2], "positional argument 3");
strus::DatabaseInterface* dbi = strus::createDatabaseType_leveldb( "", g_errorBuffer);
if (!dbi) throw strus::runtime_error( "%s", _TXT("could not create leveldb key/value store database handler"));
if (g_errorBuffer->hasError()) throw std::runtime_error( _TXT("error in initialization"));
resizeBlocks( dbi, dbconfig, blocktype, termtype, newblocksize, transactionsize, docnorange);
// Check for reported error an terminate regularly:
if (g_errorBuffer->hasError())
{
throw strus::runtime_error( "%s", _TXT("error processing resize blocks"));
}
std::cerr << _TXT("done") << std::endl;
return 0;
}
catch (const std::exception& e)
{
const char* errormsg = g_errorBuffer?g_errorBuffer->fetchError():0;
if (errormsg)
{
std::cerr << e.what() << ": " << errormsg << std::endl;
}
else
{
std::cerr << e.what() << std::endl;
}
}
std::cerr << _TXT("terminated") << std::endl;
return -1;
}
