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; }