static IMG_VOID RestructureLoopToExecPred(PINTERMEDIATE_STATE psState, PLOOP_INFO psLoopInfo, PUSC_LIST psLoopInfoLst) { PCFG psLoopCfg; IMG_BOOL bGenerateInfiniteLoop; IMG_UINT32 uLoopPredReg; IMG_BOOL bInvertLoopPredReg; RestructureLoop(psState, psLoopInfo, &psLoopCfg, &bGenerateInfiniteLoop, &uLoopPredReg, &bInvertLoopPredReg, psLoopInfoLst); RestructureNoneLoopCfgToExecPred(psState, psLoopCfg, IMG_FALSE); { PCODEBLOCK psCndEfLoopBlock = NULL; { psCndEfLoopBlock = AllocateBlock(psState, psLoopCfg); RedirectEdgesFromPredecessors(psState, psLoopCfg->psExit, psCndEfLoopBlock, IMG_FALSE); AppendExecPredInst(psState, psCndEfLoopBlock, ICNDEFLOOP, USC_PREDREG_NONE, IMG_TRUE, USC_PREDREG_NONE, 0); } { PCODEBLOCK psCndExeLtBlock = AllocateBlock(psState, psLoopCfg); IMG_UINT32 uPDstLoop = GetNextPredicateRegister(psState); AppendExecPredInst(psState, psCndExeLtBlock, ICNDLT, uLoopPredReg, bGenerateInfiniteLoop ? bGenerateInfiniteLoop : bInvertLoopPredReg, uPDstLoop, 2); SetBlockUnconditional(psState, psCndEfLoopBlock, psCndExeLtBlock); SetBlockUnconditional(psState, psCndExeLtBlock, psLoopCfg->psExit); } } SetLoopFlow(psState, psLoopCfg); { PCODEBLOCK psCndStLoopBlock; PCODEBLOCK psOldEntry = psLoopCfg->psEntry; psCndStLoopBlock = AllocateBlock(psState, psLoopCfg); AppendExecPredInst(psState, psCndStLoopBlock, ICNDSTLOOP, USC_PREDREG_NONE, IMG_TRUE /* uCondPredInv */, USC_PREDREG_NONE, 2); psLoopCfg->psEntry = psCndStLoopBlock; SetBlockUnconditional(psState, psCndStLoopBlock, psOldEntry); } }
descriptor_allocation_t DescriptorAllocator::Allocate(u32 num) { Check(num < BlockSize); auto bucket = find_log_2(num); auto m = pad_pow_2(num); u32 heapOffset = 0; if (Size(FreeRanges[bucket])) { heapOffset = Back(FreeRanges[bucket]).heap_offset; PopBack(FreeRanges[bucket]); } else { if (SuballocatedBlock[bucket] == NULL_BLOCK) { SuballocatedBlock[bucket] = AllocateBlock(); } heapOffset = SuballocatedBlock[bucket] * BlockSize + Blocks[SuballocatedBlock[bucket]].next_allocation_offset; Blocks[SuballocatedBlock[bucket]].next_allocation_offset += m; if (Blocks[SuballocatedBlock[bucket]].next_allocation_offset == BlockSize) { SuballocatedBlock[bucket] = NULL_BLOCK; } } descriptor_allocation_t allocation = {}; allocation.allocator = this; allocation.heap_offset = heapOffset; allocation.size = num; return allocation; }
void FD3D12BuddyAllocator::Allocate(uint32 SizeInBytes, uint32 Alignment, FD3D12ResourceLocation& ResourceLocation) { FScopeLock Lock(&CS); if (Initialized == false) { Initialize(); Initialized = true; } uint32 SizeToAllocate = SizeInBytes; // If the alignment doesn't match the block size if (Alignment != 0 && MinBlockSize % Alignment != 0) { SizeToAllocate = SizeInBytes + Alignment; } // Work out what size block is needed and allocate one const uint32 UnitSize = SizeToUnitSize(SizeToAllocate); const uint32 Order = UnitSizeToOrder(UnitSize); const uint32 Offset = AllocateBlock(Order); // This is the offset in MinBlockSize units const uint32 AllocSize = uint32(OrderToUnitSize(Order) * MinBlockSize); const uint32 AllocationBlockOffset = uint32(Offset * MinBlockSize); uint32 Padding = 0; if (Alignment != 0 && AllocationBlockOffset % Alignment != 0) { uint32 AlignedBlockOffset = AlignArbitrary(AllocationBlockOffset, Alignment); Padding = AlignedBlockOffset - AllocationBlockOffset; check((Padding + SizeInBytes) <= AllocSize) }
uint32 FD3D12BuddyAllocator::AllocateBlock(uint32 order) { uint32 offset; if (order > MaxOrder) { check(false); // Can't allocate a block that large } if (FreeBlocks[order].Num() == 0) { // No free nodes in the requested pool. Try to find a higher-order block and split it. uint32 left = AllocateBlock(order + 1); uint32 size = OrderToUnitSize(order); uint32 right = left + size; FreeBlocks[order].Add(right); // Add the right block to the free pool offset = left; // Return the left block } else { TSet<uint32>::TConstIterator it(FreeBlocks[order]); offset = *it; // Remove the block from the free list FreeBlocks[order].Remove(*it); } return offset; }
const RC openFile(char *fileName,PF_FileHandle *fileHandle) { int fd; PF_FileHandle *pfilehandle=fileHandle; RC tmp; if((fd=_open(fileName,O_RDWR|_O_BINARY))<0) return PF_FILEERR; pfilehandle->bopen=true; pfilehandle->fileName=fileName; pfilehandle->fileDesc=fd; if((tmp=AllocateBlock(&pfilehandle->pHdrFrame))!=SUCCESS){ _close(fd); return tmp; } pfilehandle->pHdrFrame->bDirty=false; pfilehandle->pHdrFrame->pinCount=1; pfilehandle->pHdrFrame->accTime=clock(); pfilehandle->pHdrFrame->fileDesc=fd; pfilehandle->pHdrFrame->fileName=fileName; if(_lseek(fd,0,SEEK_SET)==-1){ DisposeBlock(pfilehandle->pHdrFrame); _close(fd); return PF_FILEERR; } if(_read(fd,&(pfilehandle->pHdrFrame->page),sizeof(Page))!=sizeof(Page)){ DisposeBlock(pfilehandle->pHdrFrame); _close(fd); return PF_FILEERR; } pfilehandle->pHdrPage=&(pfilehandle->pHdrFrame->page); pfilehandle->pBitmap=pfilehandle->pHdrPage->pData+PF_FILESUBHDR_SIZE; pfilehandle->pFileSubHeader=(PF_FileSubHeader *)pfilehandle->pHdrPage->pData; fileHandle=pfilehandle; return SUCCESS; }
FIndirectLightingCacheAllocation* FIndirectLightingCache::CreateAllocation(int32 BlockSize, const FBoxSphereBounds& Bounds, bool bPointSample, bool bUnbuiltPreview) { check(BlockSize > 1 || bPointSample); FIndirectLightingCacheAllocation* NewAllocation = new FIndirectLightingCacheAllocation(); FIndirectLightingCacheBlock NewBlock; //@todo - don't allocate point samples from the layout, they don't go through the volume texture if (AllocateBlock(BlockSize, NewBlock.MinTexel)) { NewBlock.TexelSize = BlockSize; CalculateBlockPositionAndSize(Bounds, BlockSize, NewBlock.Min, NewBlock.Size); FVector Scale; FVector Add; FVector MinUV; FVector MaxUV; CalculateBlockScaleAndAdd(NewBlock.MinTexel, NewBlock.TexelSize, NewBlock.Min, NewBlock.Size, Scale, Add, MinUV, MaxUV); VolumeBlocks.Add(NewBlock.MinTexel, NewBlock); NewAllocation->SetParameters(NewBlock.MinTexel, NewBlock.TexelSize, Scale, Add, MinUV, MaxUV, bPointSample, bUnbuiltPreview); } return NewAllocation; }
globle void *RequestChunk( void *theEnv, size_t requestSize) { struct chunkInfo *chunkPtr; struct blockInfo *blockPtr; /*==================================================*/ /* Allocate initial memory pool block if it has not */ /* already been allocated. */ /*==================================================*/ if (MemoryData(theEnv)->BlockMemoryInitialized == FALSE) { if (InitializeBlockMemory(theEnv,requestSize) == 0) return(NULL); } /*====================================================*/ /* Make sure that the amount of memory requested will */ /* fall on a boundary of strictest alignment */ /*====================================================*/ requestSize = (((requestSize - 1) / STRICT_ALIGN_SIZE) + 1) * STRICT_ALIGN_SIZE; /*=====================================================*/ /* Search through the list of free memory for a block */ /* of the appropriate size. If a block is found, then */ /* allocate and return a pointer to it. */ /*=====================================================*/ blockPtr = MemoryData(theEnv)->TopMemoryBlock; while (blockPtr != NULL) { chunkPtr = blockPtr->nextFree; while (chunkPtr != NULL) { if ((chunkPtr->size == requestSize) || (chunkPtr->size > (requestSize + MemoryData(theEnv)->ChunkInfoSize))) { AllocateChunk(theEnv,blockPtr,chunkPtr,requestSize); return((void *) (((char *) chunkPtr) + MemoryData(theEnv)->ChunkInfoSize)); } chunkPtr = chunkPtr->nextFree; } if (blockPtr->nextBlock == NULL) { if (AllocateBlock(theEnv,blockPtr,requestSize) == 0) /* get another block */ { return(NULL); } } blockPtr = blockPtr->nextBlock; } SystemError(theEnv,(char*)"MEMORY",2); EnvExitRouter(theEnv,EXIT_FAILURE); return(NULL); /* Unreachable, but prevents warning. */ }
uint64 FileBundleWriter::AllocateAppend(size_t write_len) { FileBundleWriterSegment *segment; // segment to write into off_t seg_position; // position in segment file uint64 bundle_position; AllocateBlock(write_len, &segment, &seg_position, &bundle_position); return bundle_position; }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // Gets an object from the pool. void* GetObject() { // Acquire the lock. Will be automatically released by the destructor. SpinLock lock(&lock_); if((Count() == 0) || (static_cast<BlockHeader*>(First())->FreeObjects == 0)) { // No free block is available, a new one needs to be allocated. AllocateBlock(); } return GetObjectFromBlock(static_cast<BlockHeader*>(First())); }
int mkdir(char * filePath, char * fileName) { unsigned int destinationDirBlockNumber,newDirBlockNumber; directoryBlock destinationDirectory,newDirectory; int z, y, isfile; if (strCmp(filePath, "/") == 1) destinationDirBlockNumber = ROOTBLOCK; else destinationDirBlockNumber = findFileBlockInPath(filePath); if (destinationDirBlockNumber == -1) { printstring("Directory does not exists"); return -1; } filePath = getData(filePath); fileName = getData(fileName); readsector(destinationDirBlockNumber, &destinationDirectory); isfile = IsNewFile(destinationDirectory, fileName); if (isfile == -1) { printstring("Directory already exist\n"); return -1; } newDirBlockNumber = AllocateBlock(); y = 0; while(y < DIRECTORYENTRYCOUNT) { newDirectory.entries[y].fileType = IS_FILE; newDirectory.entries[y].fileBlockStart = 0; newDirectory.entries[y].fileBlockSize = 0; y++; } writesector(newDirBlockNumber, &newDirectory); z = 0; while (z < DIRECTORYENTRYCOUNT) { if (destinationDirectory.entries[z].fileBlockStart == 0) { strcpy(fileName, destinationDirectory.entries[z].fileName); destinationDirectory.entries[z].fileType = IS_DIRECTORY; destinationDirectory.entries[z].fileBlockStart = newDirBlockNumber; destinationDirectory.entries[z].fileBlockSize = 1; break; } z++; } writesector(destinationDirBlockNumber, &destinationDirectory); printstring("Directory "); printstring(fileName); printstring(" Created!\n"); return newDirBlockNumber; }
//allocators for a node CLTANode* CLTALoadOnlyAlloc::AllocateNode() { //lets first off get the memory for a node CLTANode* pNewNode = (CLTANode*)AllocateBlock(sizeof(CLTANode)); //check the alloc if(pNewNode) { pNewNode->NodeConstructor(); } return pNewNode; }
uint64 FileBundleWriter::WriteAppend(const void *buffer, size_t write_len) { if (SegmentsEmpty()) { // if bundle closed throw khSimpleException ("FileBundleWriter::WriteAppend: bundle already closed"); } FileBundleWriterSegment *segment; // segment to write into off_t seg_position; // position in segment file uint64 bundle_position; AllocateBlock(write_len, &segment, &seg_position, &bundle_position); WriteToSegment(segment, seg_position, buffer, write_len); return bundle_position; }
void mkf(char * path, char* fileName, char acess[], char *data) { int y,isfile; directoryBlock destinationDirectory; fileBlock file; unsigned int newDirBlockNumber, destinationDirBlockNumber; if (strCmp(getData(path), "/") != 1) { destinationDirBlockNumber = findFileBlockInPath(getData(path)); } else { destinationDirBlockNumber = ROOTBLOCK; } if (destinationDirBlockNumber == -1) { printstring("Path cannot be found, creating file failed"); return; } readsector(destinationDirBlockNumber, (char*)&destinationDirectory); isfile = IsNewFile(destinationDirectory, getData(fileName)); if (isfile == -1) { printstring("File already exist\n"); return; } file.size = 0; file.type = IS_FILE; file.data[0] = '\0'; strcpy(getData(fileName), file.fileName); strcpy(getData(acess), file.acessRights); strcpy(getData(data), file.data); newDirBlockNumber = AllocateBlock(); wf(&file, getData(data), newDirBlockNumber); y = 0; while( y < DIRECTORYENTRYCOUNT) { if (destinationDirectory.entries[y].fileBlockStart == 0) { strcpy(destinationDirectory.entries[y].fileName, file.fileName); destinationDirectory.entries[y].fileType = IS_FILE; destinationDirectory.entries[y].fileBlockStart = newDirBlockNumber; destinationDirectory.entries[y].fileBlockSize = file.size; break; } y++; } writesector(destinationDirBlockNumber, (char*)&destinationDirectory); return; }
static IMG_VOID RestructureNoneLoopCfgToExecPred(PINTERMEDIATE_STATE psState, PCFG psCfg, IMG_BOOL bMostOuterLevel) { PCTRL_DEP_GRAPH psCtrlDepGraph; PCODEBLOCK psNewEntryBlock; PCODEBLOCK psNewExitBlock; PCODEBLOCK psCfgActualExitBlock; if(psCfg->uNumBlocks > 1) { psNewEntryBlock = AllocateBlock(psState, psCfg); psNewExitBlock = AllocateBlock(psState, psCfg); psCfg->psExit->eType = CBTYPE_UNCOND; if (bMostOuterLevel == IMG_FALSE) { psCfgActualExitBlock = NULL; } else { psCfgActualExitBlock = psCfg->psExit; } SetBlockUnconditional(psState, psCfg->psExit, psNewExitBlock); SetBlockConditional(psState, psNewEntryBlock, GetNextPredicateRegister(psState), psCfg->psEntry, psNewExitBlock, IMG_FALSE); psCfg->psEntry = psNewEntryBlock; psNewExitBlock->eType = CBTYPE_EXIT; psCfg->psExit = psNewExitBlock; CalcDoms(psState, psCfg); psCfg->bBlockStructureChanged = IMG_FALSE; //TESTONLY_PRINT_INTERMEDIATE("After changing program structure", "beforeCtrlDep", IMG_FALSE); psCtrlDepGraph = CalcCtrlDep(psState, psCfg->psEntry); LayoutExecPredCfgFromCtrlDepGraph(psState, psCtrlDepGraph, psCfg, psCfgActualExitBlock); FreeCtrlDepGraph(psState, &psCtrlDepGraph); if (bMostOuterLevel == IMG_TRUE) { //TESTONLY_PRINT_INTERMEDIATE("After changing program structure", "returns", IMG_FALSE); OptimizeFunctionEnd(psState, psCfg->psExit); } } }
const RC AllocatePage(PF_FileHandle *fileHandle,PF_PageHandle *pageHandle) { PF_PageHandle *pPageHandle=pageHandle; RC tmp; int i,byte,bit; fileHandle->pHdrFrame->bDirty=true; if((fileHandle->pFileSubHeader->nAllocatedPages)<=(fileHandle->pFileSubHeader->pageCount)){ for(i=0;i<=fileHandle->pFileSubHeader->pageCount;i++){ byte=i/8; bit=i%8; if(((fileHandle->pBitmap[byte])&(1<<bit))==0){ (fileHandle->pFileSubHeader->nAllocatedPages)++; fileHandle->pBitmap[byte]|=(1<<bit); break; } } if(i<=fileHandle->pFileSubHeader->pageCount) return GetThisPage(fileHandle,i,pageHandle); } fileHandle->pFileSubHeader->nAllocatedPages++; fileHandle->pFileSubHeader->pageCount++; byte=fileHandle->pFileSubHeader->pageCount/8; bit=fileHandle->pFileSubHeader->pageCount%8; fileHandle->pBitmap[byte]|=(1<<bit); if((tmp=AllocateBlock(&(pPageHandle->pFrame)))!=SUCCESS){ return tmp; } pPageHandle->pFrame->bDirty=false; pPageHandle->pFrame->fileDesc=fileHandle->fileDesc; pPageHandle->pFrame->fileName=fileHandle->fileName; pPageHandle->pFrame->pinCount=1; pPageHandle->pFrame->accTime=clock(); memset(&(pPageHandle->pFrame->page),0,sizeof(Page)); pPageHandle->pFrame->page.pageNum=fileHandle->pFileSubHeader->pageCount; if(_lseek(fileHandle->fileDesc,0,SEEK_END)==-1){ bf_manager.allocated[pPageHandle->pFrame-bf_manager.frame]=false; return PF_FILEERR; } if(_write(fileHandle->fileDesc,&(pPageHandle->pFrame->page),sizeof(Page))!=sizeof(Page)){ bf_manager.allocated[pPageHandle->pFrame-bf_manager.frame]=false; return PF_FILEERR; } return SUCCESS; }
static PCODEBLOCK DuplicateCodeBlock(PINTERMEDIATE_STATE psState, PCODEBLOCK psCodeBlock, PCFG psCfg) { PINST psCurrInst; PCODEBLOCK psDuplicateCodeBlock = AllocateBlock(psState, psCfg); if (psCodeBlock->uFlags & USC_CODEBLOCK_CFG) { psDuplicateCodeBlock->u.sUncond.psCfg = DuplicateCfg(psState, psCfg); psDuplicateCodeBlock->uFlags |= USC_CODEBLOCK_CFG; } for (psCurrInst = psCodeBlock->psBody; psCurrInst != NULL; psCurrInst = psCurrInst->psNext) { PINST psDuplicateInst = CopyInst(psState, psCurrInst); AppendInst(psState, psDuplicateCodeBlock, psDuplicateInst); } CopyRegLiveSet(psState, &psCodeBlock->sRegistersLiveOut, &psDuplicateCodeBlock->sRegistersLiveOut); return psDuplicateCodeBlock; }
const RC GetThisPage(PF_FileHandle *fileHandle,PageNum pageNum,PF_PageHandle *pageHandle) { int i,nread,offset; RC tmp; PF_PageHandle *pPageHandle=pageHandle; if(pageNum>fileHandle->pFileSubHeader->pageCount) return PF_INVALIDPAGENUM; if((fileHandle->pBitmap[pageNum/8]&(1<<(pageNum%8)))==0) return PF_INVALIDPAGENUM; pPageHandle->bOpen=true; for(i=0;i<PF_BUFFER_SIZE;i++){ if(bf_manager.allocated[i]==false) continue; if(strcmp(bf_manager.frame[i].fileName,fileHandle->fileName)!=0) continue; if(bf_manager.frame[i].page.pageNum==pageNum){ pPageHandle->pFrame=bf_manager.frame+i; pPageHandle->pFrame->pinCount++; pPageHandle->pFrame->accTime=clock(); return SUCCESS; } } if((tmp=AllocateBlock(&(pPageHandle->pFrame)))!=SUCCESS){ return tmp; } pPageHandle->pFrame->bDirty=false; pPageHandle->pFrame->fileDesc=fileHandle->fileDesc; pPageHandle->pFrame->fileName=fileHandle->fileName; pPageHandle->pFrame->pinCount=1; pPageHandle->pFrame->accTime=clock(); offset=pageNum*sizeof(Page); if(_lseek(fileHandle->fileDesc,offset,SEEK_SET)==offset-1){ bf_manager.allocated[pPageHandle->pFrame-bf_manager.frame]=false; return PF_FILEERR; } if((nread=read(fileHandle->fileDesc,&(pPageHandle->pFrame->page),sizeof(Page)))!=sizeof(Page)){ bf_manager.allocated[pPageHandle->pFrame-bf_manager.frame]=false; return PF_FILEERR; } return SUCCESS; }
BOOL StoreLine( char *line, int lineLen, int *offset, BYTE *prevLength, LPBLOCKDEF * pCurBlock ) { LPLINEREC pl; if ((*offset + (LHD + lineLen)) > BLOCK_SIZE) { //We arrived at the end of the block. Allocates a new one. if (!AllocateBlock(*pCurBlock, NULL, pCurBlock)) return FALSE; ((*pCurBlock)->PrevBlock)->NextBlock = *pCurBlock; *offset = 0; if ((*pCurBlock)->PrevBlock == NULL) *prevLength = 0; } (*pCurBlock)->LastLineOffset = *offset; pl = (LPLINEREC)((*pCurBlock)->Data + *offset); AssertAligned(pl); pl->PrevLength = *prevLength; pl->Length = (BYTE)(LHD + lineLen); pl->Status = 0; memmove((LPSTR)(pl->Text), (LPSTR)line, lineLen); *prevLength = (BYTE)(LHD + lineLen); *offset += LHD + lineLen; #ifdef ALIGN *offset = (*offset + 3) & ~3; #endif return TRUE; } /* StoreLine() */
static void* OperatorNew( size_t s ) { if ( !using_alloc_set ) { simulate_possible_failure(); alloc_count++; } char *p = AllocateBlock(s); if ( gTestController.TrackingEnabled() && gTestController.LeakDetectionEnabled() && !using_alloc_set ) { using_alloc_set = true; EH_ASSERT( alloc_set().find( p ) == alloc_set().end() ); alloc_set().insert( p ); using_alloc_set = false; } return p; }
FIndirectLightingCacheAllocation* FIndirectLightingCache::CreateAllocation(int32 BlockSize, const FBoxSphereBounds& Bounds, bool bOpaqueRelevance) { FIndirectLightingCacheAllocation* NewAllocation = new FIndirectLightingCacheAllocation(); FIndirectLightingCacheBlock NewBlock; if (AllocateBlock(BlockSize, NewBlock.MinTexel)) { NewBlock.TexelSize = BlockSize; CalculateBlockPositionAndSize(Bounds, BlockSize, NewBlock.Min, NewBlock.Size); FVector Scale; FVector Add; FVector MinUV; FVector MaxUV; CalculateBlockScaleAndAdd(NewBlock.MinTexel, NewBlock.TexelSize, NewBlock.Min, NewBlock.Size, Scale, Add, MinUV, MaxUV); VolumeBlocks.Add(NewBlock.MinTexel, NewBlock); NewAllocation->SetParameters(NewBlock.MinTexel, NewBlock.TexelSize, Scale, Add, MinUV, MaxUV, bOpaqueRelevance); } return NewAllocation; }
StormFixedBlockHandle StormFixedBlockAllocator::AllocateBlock(StormFixedBlockHandle chain_head, StormFixedBlockType::Index type) { StormFixedBlockHandle new_block = AllocateBlock(type); SetNextBlock(chain_head, new_block); return new_block; }
void CachedInterpreter::Jit(u32 address) { if (m_code.size() >= CODE_SIZE / sizeof(Instruction) - 0x1000 || IsFull() || SConfig::GetInstance().bJITNoBlockCache) { ClearCache(); } u32 nextPC = analyzer.Analyze(PC, &code_block, &code_buffer, code_buffer.GetSize()); if (code_block.m_memory_exception) { // Address of instruction could not be translated NPC = nextPC; PowerPC::ppcState.Exceptions |= EXCEPTION_ISI; PowerPC::CheckExceptions(); WARN_LOG(POWERPC, "ISI exception at 0x%08x", nextPC); return; } int block_num = AllocateBlock(PC); JitBlock *b = GetBlock(block_num); js.blockStart = PC; js.firstFPInstructionFound = false; js.fifoBytesThisBlock = 0; js.downcountAmount = 0; js.curBlock = b; PPCAnalyst::CodeOp *ops = code_buffer.codebuffer; b->checkedEntry = GetCodePtr(); b->normalEntry = GetCodePtr(); b->runCount = 0; for (u32 i = 0; i < code_block.m_num_instructions; i++) { js.downcountAmount += ops[i].opinfo->numCycles; u32 function = HLE::GetFunctionIndex(ops[i].address); if (function != 0) { int type = HLE::GetFunctionTypeByIndex(function); if (type == HLE::HLE_HOOK_START || type == HLE::HLE_HOOK_REPLACE) { int flags = HLE::GetFunctionFlagsByIndex(function); if (HLE::IsEnabled(flags)) { m_code.emplace_back(WritePC, ops[i].address); m_code.emplace_back(Interpreter::HLEFunction, ops[i].inst); if (type == HLE::HLE_HOOK_REPLACE) { m_code.emplace_back(EndBlock, js.downcountAmount); m_code.emplace_back(); break; } } } } if (!ops[i].skip) { if ((ops[i].opinfo->flags & FL_USE_FPU) && !js.firstFPInstructionFound) { m_code.emplace_back(CheckFPU, ops[i].address); js.firstFPInstructionFound = true; } if (ops[i].opinfo->flags & FL_ENDBLOCK) m_code.emplace_back(WritePC, ops[i].address); m_code.emplace_back(GetInterpreterOp(ops[i].inst), ops[i].inst); if (ops[i].opinfo->flags & FL_ENDBLOCK) m_code.emplace_back(EndBlock, js.downcountAmount); } } if (code_block.m_broken) { m_code.emplace_back(WritePC, nextPC); m_code.emplace_back(EndBlock, js.downcountAmount); } m_code.emplace_back(); b->codeSize = (u32)(GetCodePtr() - b->checkedEntry); b->originalSize = code_block.m_num_instructions; FinalizeBlock(block_num, jo.enableBlocklink, b->checkedEntry); }
virtual void Run() { SetName("ZLibCompressor"); #if defined (DURANGO) SetThreadAffinityMask(GetCurrentThread(), BIT(3)); #endif while(!m_bCancelled || !m_files.empty()) { m_event.Wait(); uint8* pZLibCompressedBuffer = AllocateBlock(); while(!m_files.empty()) { CFile* pFile = m_files.pop(); assert(pFile); PREFAST_ASSUME(pFile); while(!pFile->Closed() || !pFile->m_blocks.empty()) { if( pFile->m_blocks.empty() ) { CrySleep(1); // yield to give other threads a chance to do some work } while(!pFile->m_blocks.empty()) { SZLibBlock* block = pFile->m_blocks.pop(); assert(block); PREFAST_ASSUME(block); if(pFile->m_pCompressor->m_bUseZLibCompression) { size_t compressedLength = XMLCPB_ZLIB_BUFFER_SIZE; bool compressionOk = gEnv->pSystem->CompressDataBlock( block->m_pZLibBuffer, block->m_ZLibBufferSizeUsed, pZLibCompressedBuffer, compressedLength ); SZLibBlockHeader zlibHeader; zlibHeader.m_compressedSize = compressionOk ? compressedLength : SZLibBlockHeader::NO_ZLIB_USED; zlibHeader.m_uncompressedSize = block->m_ZLibBufferSizeUsed; pFile->m_bytesWrittenIntoFileUncompressed += block->m_ZLibBufferSizeUsed; pFile->Write( &zlibHeader, sizeof(SZLibBlockHeader) ); if (compressionOk) pFile->Write( pZLibCompressedBuffer, compressedLength ); else pFile->Write( block->m_pZLibBuffer, block->m_ZLibBufferSizeUsed ); } else { pFile->Write(block->m_pZLibBuffer, block->m_ZLibBufferSizeUsed); } delete block; } } pFile->Finish(); delete pFile; } FreeBlock(pZLibCompressedBuffer); } }
void AllocateBlocks(int n){ int i=0; for (i; i<n; i+=1) AllocateBlock(); getch(); }
// ResizeBlock Block * BlockAllocator::Area::ResizeBlock(Block *block, size_t newUsableSize, bool dontDefragment) { //PRINT(("Area::ResizeBlock(%p, %lu)\n", block, newUsableSize)); // newUsableSize must be >0 ! if (newUsableSize == 0) return NULL; Block *resultBlock = NULL; if (block) { size_t size = block->GetSize(); size_t newSize = max(newUsableSize + sizeof(BlockHeader), kMinBlockSize); newSize = block_align_ceil(newSize); if (newSize == size) { // size doesn't change: nothing to do resultBlock = block; } else if (newSize < size) { // shrink the block size_t sizeDiff = size - newSize; Block *nextBlock = block->GetNextBlock(); if (nextBlock && nextBlock->IsFree()) { // join the space with the adjoining free block TFreeBlock *freeBlock = nextBlock->ToFreeBlock(); _MoveResizeFreeBlock(freeBlock, -sizeDiff, freeBlock->GetSize() + sizeDiff); // resize the block and we're done block->SetSize(newSize, true); fFreeBytes += sizeDiff; } else if (sizeDiff >= sizeof(TFreeBlock)) { // the freed space is large enough for a free block TFreeBlock *newFree = _MakeFreeBlock(block, newSize, block, sizeDiff, nextBlock, NULL, NULL); _InsertFreeBlock(newFree); block->SetSize(newSize, true); if (fFreeBlockCount == 1) fFreeBytes += newFree->GetUsableSize(); else fFreeBytes += newFree->GetSize(); if (!dontDefragment && _DefragmentingRecommended()) _Defragment(); } // else: insufficient space for a free block: no changes resultBlock = block; } else { //PRINT((" grow...\n")); // grow the block size_t sizeDiff = newSize - size; Block *nextBlock = block->GetNextBlock(); if (nextBlock && nextBlock->IsFree() && nextBlock->GetSize() >= sizeDiff) { //PRINT((" adjoining free block\n")); // there is a adjoining free block and it is large enough TFreeBlock *freeBlock = nextBlock->ToFreeBlock(); size_t freeSize = freeBlock->GetSize(); if (freeSize - sizeDiff >= sizeof(TFreeBlock)) { // the remaining space is still large enough for a free // block _MoveResizeFreeBlock(freeBlock, sizeDiff, freeSize - sizeDiff); block->SetSize(newSize, true); fFreeBytes -= sizeDiff; } else { // the remaining free space wouldn't be large enough for // a free block: consume the free block completely Block *freeNext = freeBlock->GetNextBlock(); _RemoveFreeBlock(freeBlock); block->SetSize(size + freeSize, freeNext); _FixBlockList(block, block->GetPreviousBlock(), freeNext); if (fFreeBlockCount == 0) fFreeBytes = 0; else fFreeBytes -= freeSize; } resultBlock = block; } else { //PRINT((" no adjoining free block\n")); // no (large enough) adjoining free block: allocate // a new block and copy the data to it BlockReference *reference = block->GetReference(); resultBlock = AllocateBlock(newUsableSize, dontDefragment); block = reference->GetBlock(); if (resultBlock) { resultBlock->SetReference(reference); memcpy(resultBlock->GetData(), block->GetData(), block->GetUsableSize()); FreeBlock(block, dontDefragment); resultBlock = reference->GetBlock(); } } } } D(SanityCheck()); //PRINT(("Area::ResizeBlock() done: %p\n", resultBlock)); return resultBlock; }
BOOL FAR MergeFile(LPSTR FileName, int view) { HCURSOR hSaveCursor; char line[MAX_USER_LINE + 1]; int offset; //Current offset of storage in block int lineLen; // length of line BYTE prevLength; //Previous line size LPVIEWREC v = &Views[view]; WORD res; LPDOCREC d =&Docs[v->Doc]; LPLINEREC pCurLine, pLastLine; LPBLOCKDEF pCurBlock, pNewBlock; long y; Assert( v->Doc >= 0); if ((hFileDoc = _lopen(FileName, OF_READ)) == HFILE_ERROR) return ErrorBox(ERR_File_Open, (LPSTR)FileName); if ((pszBufferDoc = DocAlloc(DISK_BLOCK_SIZE)) == NULL) { ErrorBox(SYS_Allocate_Memory); goto error1; } dwBytesReadDoc = DISK_BLOCK_SIZE; dwOffsetDoc = DISK_BLOCK_SIZE; lineLen = 0; //Delete selected text if any if (v->BlockStatus) { long XR, YR; GetBlockCoord (view, &(v->X), &(v->Y), &XR, &YR); DeleteStream(view, v->X, v->Y, XR, YR, FALSE); } //Set the Hour glass cursor hSaveCursor = SetCursor(LoadCursor(NULL, IDC_WAIT)); //Insert first line res = LoadLine(line, &lineLen, d->NbLines); if (res == END_OF_FILE || res == END_OF_LINE) { //Add a CR+LF if (res == END_OF_LINE) { line[lineLen] = CR; line[lineLen + 1] = LF; lineLen += 2; } if (!InsertBlock(v->Doc, v->X, v->Y, (WORD) lineLen, line)) goto error2; } else { if (res == ERR_File_Read || res == ERR_Not_A_Text_File) ErrorBox(res, (LPSTR)FileName); goto error2; } if (res != END_OF_FILE) { //Get current line status (we just inserted it) y = v->Y; if (!FirstLine(v->Doc, &pCurLine, &y, &pCurBlock)) return FALSE; //Get next line (just after the line we just inserted) if (!NextLine(v->Doc, &pCurLine, &y, &pCurBlock)) return FALSE; //Set offset to StoreLine start offset = (LPSTR)pCurLine - (LPSTR)pCurBlock->Data; prevLength = pCurLine->PrevLength; //Split block in 2 blocks by first allocating a new block and then //copying right side of block in new block if (!AllocateBlock(pCurBlock, pCurBlock->NextBlock, &pNewBlock)) return FALSE; pLastLine = (LPLINEREC)(pCurBlock->Data + pCurBlock->LastLineOffset); memmove(pNewBlock->Data, (LPSTR)pCurLine, (LPSTR)pLastLine - (LPSTR)pCurLine + pLastLine->Length); //Set new old block len and new new block len pCurBlock->LastLineOffset = (LPSTR)pCurLine - (LPSTR)pCurBlock->Data - pCurLine->PrevLength; pNewBlock->LastLineOffset = (LPSTR)pLastLine - (LPSTR)pCurLine; //Backward links next block with new one if (pCurBlock->NextBlock == NULL) d->LastBlock = pNewBlock; else (pCurBlock->NextBlock)->PrevBlock = pNewBlock; //Forward link current block with new block pCurBlock->NextBlock = pNewBlock; CloseLine(v->Doc, &pCurLine, y, &pCurBlock); //Read and store all lines in new blocks res = LoadLine(line, &lineLen, d->NbLines); while (res == END_OF_LINE) { //Truncate a file too large if (d->NbLines >= MAX_LINE_NUMBER - 1) { ErrorBox(ERR_Truncate_Doc); res = END_OF_FILE; break; } if (!StoreLine(line, lineLen, &offset, &prevLength, &pCurBlock)) { res = END_ABORT; break; } res = LoadLine(line, &lineLen, ++d->NbLines); } //Take decisions switch (res) { case END_OF_FILE: //Store last line if (StoreLine(line, lineLen, &offset, &prevLength, &pCurBlock)) { d->NbLines++; //Forward link of last allocated block with new block pCurBlock->NextBlock = pNewBlock; //Backward link of new block with last allocated block pNewBlock->PrevBlock = pCurBlock; ((LPLINEREC)(pNewBlock->Data))->PrevLength = (BYTE)(lineLen + LHD); //Free memory if (!DocFree(pszBufferDoc)) InternalErrorBox(SYS_Free_Memory); //Restore cursor SetCursor(hSaveCursor); //Check syntax if C if (d->language == C_LANGUAGE) { d->lineTop = 0; d->lineBottom = d->NbLines; CheckSyntax(v->Doc); } SetVerticalScrollBar(view, TRUE); PosXY(view, v->X, v->Y, FALSE); InvalidateRect(v->hwndClient, (LPRECT)NULL, FALSE); CloseHandle (hFileDoc); return TRUE; } else goto abort; case ERR_File_Read: case ERR_Not_A_Text_File: ErrorBox(res, (LPSTR)FileName); //Fall through case END_ABORT: { abort: SetCursor(hSaveCursor); break; } default: Assert(FALSE); break; } } else InvalidateRect(v->hwndClient, (LPRECT)NULL, FALSE); error2: { SetCursor (hSaveCursor); if (!DocFree(pszBufferDoc)) InternalErrorBox(SYS_Free_Memory); } error1: { CloseHandle (hFileDoc); } return FALSE; } /* MergeFile() */
BOOL LoadFile( int doc ) { LPDOCREC d =&Docs[doc]; char line[MAX_USER_LINE + 1]; int offset; //Current offset of storage in block int lineLen; BYTE prevLength; //Previous line size HCURSOR hSaveCursor; WORD res; WORD nbLines = 0; // // Documents are now always read only. Because WinDbg is no longer and IDE, it // is strictly a debugger now. // hFileDoc = CreateFile(d->szFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (INVALID_HANDLE_VALUE == hFileDoc) { ErrorBox( ERR_File_Open, (LPSTR)d->szFileName ); return FALSE; } d->readOnly = TRUE; //Store file date if (!GetFileTimeByName( d->szFileName, NULL, NULL, &d->time ) ) { GetSystemTimeAsFileTime(&d->time); } if ((pszBufferDoc = DocAlloc(DISK_BLOCK_SIZE)) == NULL) { ErrorBox(SYS_Allocate_Memory); goto error1; } //Alloc first block if (!AllocateBlock(NULL, NULL, &d->FirstBlock)) { return FALSE; } //If we are in reload mode, and a message box shows up, a repaint //of the document being loaded is done, so force number of lines //to a value != 0 d->NbLines = MAX_LINE_NUMBER; d->LastBlock = d->FirstBlock; dwBytesReadDoc = DISK_BLOCK_SIZE; dwOffsetDoc = DISK_BLOCK_SIZE; offset = 0; prevLength = 0; //Set the Hour glass cursor hSaveCursor = SetCursor (LoadCursor(NULL, IDC_WAIT)); //Read file line after line res = LoadLine(line, &lineLen, nbLines); while (res == END_OF_LINE) { //Truncate a file too large if (nbLines >= MAX_LINE_NUMBER - 1) { ErrorBox(ERR_Truncate_Doc); res = END_OF_FILE; break; } if (!StoreLine(line, lineLen, &offset, &prevLength, &d->LastBlock)) { res = END_ABORT; break; } res = LoadLine(line, &lineLen, ++nbLines); } //Take decisions switch (res) { case END_OF_FILE: //Store last line if (StoreLine(line, lineLen, &offset, &prevLength, &d->LastBlock)) { nbLines++; //Free memory if (!DocFree(pszBufferDoc)) InternalErrorBox(SYS_Free_Memory); //Restore cursor SetCursor(hSaveCursor); CloseHandle(hFileDoc); d->NbLines = nbLines; return TRUE; } else goto abort; case ERR_File_Read: case ERR_Not_A_Text_File: ErrorBox(res, (LPSTR)d->szFileName); //Fall through case END_ABORT: { LPBLOCKDEF pB; abort: while (TRUE) { pB = (d->LastBlock)->PrevBlock; if (!DocFree((LPSTR)d->LastBlock)) InternalErrorBox(SYS_Free_Memory); d->LastBlock = pB; if (pB == NULL) break; } SetCursor(hSaveCursor); break; } default: Assert(FALSE); break; } //Restore cursor SetCursor(hSaveCursor); if (!DocFree(pszBufferDoc)) InternalErrorBox(SYS_Free_Memory); error1: { CloseHandle(hFileDoc); } return FALSE; } /* LoadFile() */
void csMeshGenerator::UpdateForPosition (const csVector3& pos) { csVector3 delta = pos - last_pos; last_pos = pos; SetupSampleBox (); for (size_t i = 0 ; i < geometries.GetSize () ; i++) { geometries[i]->UpdatePosition (pos); } int cellx = GetCellX (pos.x); int cellz = GetCellZ (pos.z); // Total maximum distance for all geometries. float md = GetTotalMaxDist (); float sqmd = md * md; // Same in cell counts: int cell_x_md = 1+int (md * samplefact_x); int cell_z_md = 1+int (md * samplefact_z); // @@@ This can be done more efficiently. csVector2 pos2d (pos.x, pos.z); int x, z; int minz = cellz - cell_z_md; if (minz < 0) minz = 0; int maxz = cellz + cell_z_md+1; if (maxz > cell_dim) maxz = cell_dim; int minx = cellx - cell_x_md; if (minx < 0) minx = 0; int maxx = cellx + cell_x_md+1; if (maxx > cell_dim) maxx = cell_dim; // Calculate the intersection of minx, ... with prev_minx, ... // This intersection represent all cells that are not used this frame // but may potentially have gotten meshes the previous frame. We need // to free those meshes. csRect cur_cells (minx, minz, maxx, maxz); if (!prev_cells.IsEmpty ()) { for (z = prev_cells.ymin ; z < prev_cells.ymax ; z++) for (x = prev_cells.xmin ; x < prev_cells.xmax ; x++) if (!cur_cells.Contains (x, z)) { int cidx = z*cell_dim + x; csMGCell& cell = cells[cidx]; FreeMeshesInBlock (cidx, cell); } } prev_cells = cur_cells; int total_needed = 0; // Now allocate the cells that are close enough. for (z = minz ; z < maxz ; z++) { int cidx = z*cell_dim + minx; for (x = minx ; x < maxx ; x++) { csMGCell& cell = cells[cidx]; float sqdist = cell.box.SquaredPosDist (pos2d); if (sqdist < sqmd) { total_needed++; if (total_needed >= max_blocks) { engine->Error ( "The mesh generator needs more blocks than %d!", max_blocks); return; // @@@ What to do here??? } AllocateBlock (cidx, cell); AllocateMeshes (cidx, cell, pos, delta); } else { // Block is out of range. We keep the block in the cache // but free all meshes that are in it. FreeMeshesInBlock (cidx, cell); } cidx++; } } // Housekeeping size_t i; for (i = 0 ; i < geometries.GetSize () ; i++) { geometries[i]->FinishUpdate (); } }
size_t DiskCachingFileLoaderCache::SaveIntoCache(FileLoader *backend, s64 pos, size_t bytes, void *data, FileLoader::Flags flags) { lock_guard guard(lock_); if (!f_) { // Just to keep things working. return backend->ReadAt(pos, bytes, data, flags); } s64 cacheStartPos = pos / blockSize_; s64 cacheEndPos = (pos + bytes - 1) / blockSize_; size_t readSize = 0; size_t offset = (size_t)(pos - (cacheStartPos * (u64)blockSize_)); u8 *p = (u8 *)data; size_t blocksToRead = 0; for (s64 i = cacheStartPos; i <= cacheEndPos; ++i) { auto &info = index_[i]; if (info.block != INVALID_BLOCK) { break; } ++blocksToRead; if (blocksToRead >= MAX_BLOCKS_PER_READ) { break; } } if (!MakeCacheSpaceFor(blocksToRead) || blocksToRead == 0) { return 0; } if (blocksToRead == 1) { auto &info = index_[cacheStartPos]; u8 *buf = new u8[blockSize_]; size_t readBytes = backend->ReadAt(cacheStartPos * (u64)blockSize_, blockSize_, buf, flags); // Check if it was written while we were busy. Might happen if we thread. if (info.block == INVALID_BLOCK && readBytes != 0) { info.block = AllocateBlock((u32)cacheStartPos); WriteBlockData(info, buf); WriteIndexData((u32)cacheStartPos, info); } size_t toRead = std::min(bytes - readSize, (size_t)blockSize_ - offset); memcpy(p + readSize, buf + offset, toRead); readSize += toRead; delete [] buf; } else { u8 *wholeRead = new u8[blocksToRead * blockSize_]; size_t readBytes = backend->ReadAt(cacheStartPos * (u64)blockSize_, blocksToRead * blockSize_, wholeRead, flags); for (size_t i = 0; i < blocksToRead; ++i) { auto &info = index_[cacheStartPos + i]; // Check if it was written while we were busy. Might happen if we thread. if (info.block == INVALID_BLOCK && readBytes != 0) { info.block = AllocateBlock((u32)cacheStartPos + (u32)i); WriteBlockData(info, wholeRead + (i * blockSize_)); // TODO: Doing each index together would probably be better. WriteIndexData((u32)cacheStartPos + (u32)i, info); } size_t toRead = std::min(bytes - readSize, (size_t)blockSize_ - offset); memcpy(p + readSize, wholeRead + (i * blockSize_) + offset, toRead); readSize += toRead; } delete[] wholeRead; } cacheSize_ += blocksToRead; ++generation_; if (generation_ == std::numeric_limits<u16>::max()) { RebalanceGenerations(); } return readSize; }
descriptor_allocation_t DescriptorAllocator::AllocateTemporary(u32 num) { if (!Size(TemporaryBlocks)) { ScopeLock lock(&TemporaryBlocksCS); if (!Size(TemporaryBlocks)) { PushBack(TemporaryBlocks, AllocateBlock()); CurrentTemporaryBlockIndex = 0; } } descriptor_allocation_t allocation = {}; allocation.allocator = this; allocation.size = num; u16 currentTmpBlockIndex; u16 blockToTry; u32 blockNextAllocation; //{ // ScopeLock lock(&TemporaryBlocksCS); // currentTmpBlockIndex = CurrentTemporaryBlockIndex.load(); // blockToTry = TemporaryBlocks[currentTmpBlockIndex]; // blockNextAllocation = Blocks[blockToTry].next_allocation_offset.load(); //} currentTmpBlockIndex = CurrentTemporaryBlockIndex.load(); blockToTry = TemporaryBlocks[currentTmpBlockIndex]; blockNextAllocation = Blocks[blockToTry].next_allocation_offset.load(); while (true) { if (blockNextAllocation + num <= BlockSize) { auto expected = blockNextAllocation; if (Blocks[blockToTry].next_allocation_offset.compare_exchange_strong(expected, blockNextAllocation + num)) { allocation.heap_offset = blockToTry * BlockSize + blockNextAllocation; break; } blockNextAllocation = expected; } else { Check(currentTmpBlockIndex <= Size(TemporaryBlocks)); if (currentTmpBlockIndex + 1 == Size(TemporaryBlocks)) { while (CurrentTemporaryBlockIndex + 1 == Size(TemporaryBlocks)) { if (TemporaryBlocksCS.TryLock()) { PushBack(TemporaryBlocks, AllocateBlock()); TemporaryBlocksCS.Unlock(); } else { _mm_pause(); } } } auto expected = currentTmpBlockIndex; if (CurrentTemporaryBlockIndex.compare_exchange_strong(expected, currentTmpBlockIndex + 1)) { currentTmpBlockIndex = currentTmpBlockIndex + 1; } else { currentTmpBlockIndex = expected; } Check(currentTmpBlockIndex < Size(TemporaryBlocks)); blockToTry = TemporaryBlocks[currentTmpBlockIndex]; blockNextAllocation = Blocks[blockToTry].next_allocation_offset.load(); } } return allocation; }