StandardMemoryPool :: StandardMemoryPool(uint64 sizeInBytes, uint32 boundsCheck)
{
if(!sizeInBytes)
{
mem_error_log("Can not create memory pool with size 0");
}
m_poolSize = sizeInBytes;
m_boundsCheck = boundsCheck;
m_poolMemory = new uint8[sizeInBytes];
//Log
mem_debug_log("StandardPool Constructor initialization in address %p with size %lu\n", m_poolMemory, sizeInBytes);
mem_debug_log("StandardPool created with m_trashOnCreation:%d m_trashOnAlloc: %d m_trashOnFree :%d m_boundsCheck %d", m_trashOnCreation, m_trashOnAlloc, m_trashOnFree, m_boundsCheck);
m_freePoolSize = sizeInBytes - sizeof(Chunk);
m_totalPoolSize = sizeInBytes;
// Trash it if required
if(m_trashOnCreation)
{
memset(m_poolMemory, s_trashOnCreation, sizeInBytes);
}
if(m_boundsCheck)
{
m_freePoolSize -= s_boundsCheckSize * 2;
Chunk freeChunk(sizeInBytes - sizeof(Chunk) - 2 * s_boundsCheckSize);
freeChunk.name_set(MEMORY_POOL_BLOCK_NAME);
freeChunk.write(m_poolMemory + s_boundsCheckSize);
memcpy(m_poolMemory, s_startBound, s_boundsCheckSize);
memcpy(m_poolMemory + sizeInBytes - s_boundsCheckSize, s_endBound, s_boundsCheckSize);
freeChunk.m_next = NULL;
freeChunk.m_prev = NULL;
}
else
{
Chunk freeChunk(sizeInBytes - sizeof(Chunk));
freeChunk.name_set(MEMORY_POOL_BLOCK_NAME);
freeChunk.write(m_poolMemory);
freeChunk.m_next = NULL;
freeChunk.m_prev = NULL;
}
#ifdef MEM_DEBUG_ON
dumpToStdOut(DUMP_ELEMENT_PER_LINE, DUMP_HEX);
#endif
}
void ObjectMemory::deallocate(OTE* ote)
{
#ifdef _DEBUG
ASSERT(!ote->isFree());
if (Interpreter::executionTrace)
{
tracelock lock(TRACESTREAM);
TRACESTREAM << ote << " (" << hex << (UINT)ote << "), refs " << dec << (int)ote->m_count << ", is being deallocated" << endl;
}
#endif
ASSERT(!isPermanent(ote));
// We can have up to 256 different destructors (8 bits)
switch (ote->heapSpace())
{
case OTEFlags::NormalSpace:
freeChunk(ote->m_location);
releasePointer(ote);
break;
case OTEFlags::VirtualSpace:
::VirtualFree(static_cast<VirtualObject*>(ote->m_location)->getHeader(), 0, MEM_RELEASE);
releasePointer(ote);
break;
case OTEFlags::BlockSpace:
Interpreter::m_otePools[Interpreter::BLOCKPOOL].deallocate(ote);
break;
case OTEFlags::ContextSpace:
// Return it to the interpreter's free list of contexts
Interpreter::m_otePools[Interpreter::CONTEXTPOOL].deallocate(ote);
break;
case OTEFlags::DWORDSpace:
Interpreter::m_otePools[Interpreter::DWORDPOOL].deallocate(ote);
break;
case OTEFlags::HeapSpace:
//_asm int 3;
HARDASSERT(FALSE);
break;
case OTEFlags::FloatSpace:
Interpreter::m_otePools[Interpreter::FLOATPOOL].deallocate(ote);
break;
case OTEFlags::PoolSpace:
{
MWORD size = ote->sizeOf();
HARDASSERT(size <= MaxSmallObjectSize);
freeSmallChunk(ote->m_location, size);
releasePointer(ote);
}
break;
default:
ASSERT(false);
}
}
bool MySoundEffect::loadChunk(const char * path)
{
freeChunk();
chunk = Mix_LoadWAV(path);
return chunk != NULL;
}
void CachingReader::process() {
ReaderStatusUpdate status;
while (m_readerStatusFIFO.read(&status, 1) == 1) {
CachingReaderChunkForOwner* pChunk = static_cast<CachingReaderChunkForOwner*>(status.chunk);
if (pChunk) {
// Take over control of the chunk from the worker.
// This has to be done before freeing all chunks
// after a new track has been loaded (see below)!
pChunk->takeFromWorker();
if (status.status != CHUNK_READ_SUCCESS) {
// Discard chunks that are empty (EOF) or invalid
freeChunk(pChunk);
}
}
if (status.status == TRACK_NOT_LOADED) {
m_readerStatus = status.status;
} else if (status.status == TRACK_LOADED) {
m_readerStatus = status.status;
// Reset the max. readable frame index
m_maxReadableFrameIndex = status.maxReadableFrameIndex;
// Free all chunks with sample data from a previous track
freeAllChunks();
}
// Adjust the max. readable frame index
if (m_readerStatus == TRACK_LOADED) {
m_maxReadableFrameIndex = math_min(status.maxReadableFrameIndex, m_maxReadableFrameIndex);
} else {
m_maxReadableFrameIndex = Mixxx::AudioSource::getMinFrameIndex();
}
}
}
void CMemoryManager::clearMemory(void) {
SMemoryBlock* block = nullptr;
for (block = m_headBlock; block; block = m_headBlock) {
freeChunk(&block->memChunk);
}
m_totalMemorySize = 0;
}
void generateASM(ANTLR3_BASE_TREE *node) {
debug(DEBUG_GENERATION, "\033[22;93mGenerate ASM\033[0m");
initRegisters();
program = initChunk();
addInstruction(program, "SP EQU R15");
addInstruction(program, "FP EQU R14");
addInstruction(program, "DISPLAY EQU R13");
// TODO - dynamise load adr
addInstruction(program, "ORG 0xE000");
addInstruction(program, "START MAIN");
chunk *stack = stackEnvironement();
chunk *instructionASM = computeInstruction(node);
chunk *unstack = unstackEnvironement();
addInstruction(program, "\n\n\n// PRGM");
addEtiquette(program, "MAIN");
addInstruction(program, "STACKBASE 0x1000");
addInstruction(program, "LDW FP, SP");
addInstruction(program, "LDW DISPLAY, #0x2000");
addInstruction(program, "// STACK FACK RETURN");
addInstruction(program, "ADQ -2, SP");
appendChunks(program, stack);
appendChunks(program, instructionASM);
appendChunks(program, unstack);
addInstruction(program, "// UNSTACK FACK RETURN");
addInstruction(program, "ADQ 2, SP");
FILE *file = fopen("a.asm", "w");
fprintf(file, program->string);
fclose(file);
// printChunk(program);
freeChunk(instructionASM);
freeChunk(stack);
freeChunk(unstack);
freeChunk(program);
}
void freeWorld(World *world) {
int i;
for (i = 0; i < world->num_chunks; i++) {
freeChunk(world->chunks[i]);
}
free(world->chunks);
free(world);
}
void Allocator::reset()
{
Chunk *c = current_chunk;
while (c) {
Chunk *prev = c->prev;
freeChunk(c);
c = prev;
}
current_chunk = NULL;
current_top = NULL;
current_limit = NULL;
postReset();
}
CachingReaderChunkForOwner* CachingReader::allocateChunkExpireLRU(SINT chunkIndex) {
CachingReaderChunkForOwner* pChunk = allocateChunk(chunkIndex);
if (pChunk == nullptr) {
if (m_lruCachingReaderChunk == nullptr) {
qDebug() << "ERROR: No LRU chunk to free in allocateChunkExpireLRU.";
return nullptr;
}
freeChunk(m_lruCachingReaderChunk);
pChunk = allocateChunk(chunkIndex);
}
//qDebug() << "allocateChunkExpireLRU" << chunk << pChunk;
return pChunk;
}
Chunk* CachingReader::allocateChunkExpireLRU() {
Chunk* chunk = allocateChunk();
if (chunk == NULL) {
if (m_lruChunk == NULL) {
qDebug() << "ERROR: No LRU chunk to free in allocateChunkExpireLRU.";
return NULL;
}
//qDebug() << "Expiring LRU" << m_lruChunk << m_lruChunk->chunk_number;
freeChunk(m_lruChunk);
chunk = allocateChunk();
}
//qDebug() << "allocateChunkExpireLRU" << chunk;
return chunk;
}
static BOOL GT2_Load(BOOL curious)
{
GT_CHUNK *tmp;
_mm_fseek(modreader, 0, SEEK_SET);
while ((tmp = loadChunk()) != NULL) {
#ifdef MIKMOD_DEBUG
/* FIXME: to be completed */
fprintf(stderr, "%c%c%c%c\n", tmp->id[0], tmp->id[1], tmp->id[2], tmp->id[3]);
#endif
freeChunk(tmp);
}
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
void CachingReader::process() {
ReaderStatusUpdate status;
while (m_readerStatusFIFO.read(&status, 1) == 1) {
// qDebug() << "Got ReaderStatusUpdate:" << status.status
// << (status.chunk ? status.chunk->chunk_number : -1);
if (status.status == TRACK_NOT_LOADED) {
m_readerStatus = status.status;
} else if (status.status == TRACK_LOADED) {
freeAllChunks();
m_readerStatus = status.status;
m_iTrackNumSamplesCallbackSafe = status.trackNumSamples;
} else if (status.status == CHUNK_READ_SUCCESS) {
Chunk* pChunk = status.chunk;
if (pChunk == NULL) {
qDebug() << "ERROR: status.chunk is NULL in CHUNK_READ_SUCCESS ReaderStatusUpdate. Ignoring update.";
continue;
}
Chunk* pChunk2 = m_chunksBeingRead.take(pChunk->chunk_number);
if (pChunk2 != pChunk) {
qDebug() << "Mismatch in requested chunk to read!";
}
Chunk* pAlreadyExisting = lookupChunk(pChunk->chunk_number);
// If this chunk is already in the cache, then we just freshened
// it. Free this chunk.
if (pAlreadyExisting != NULL) {
qDebug() << "CHUNK" << pChunk->chunk_number << "ALREADY EXISTS!";
freeChunk(pChunk);
} else {
//qDebug() << "Inserting chunk" << pChunk << pChunk->chunk_number;
m_allocatedChunks.insert(pChunk->chunk_number, pChunk);
// Insert the chunk into the LRU list
m_mruChunk = insertIntoLRUList(pChunk, m_mruChunk);
// If this chunk has no next LRU then it is the LRU. This only
// happens if this is the first allocated chunk.
if (pChunk->next_lru == NULL) {
m_lruChunk = pChunk;
}
}
} else if (status.status == CHUNK_READ_EOF) {
Chunk* pChunk = status.chunk;
if (pChunk == NULL) {
qDebug() << "ERROR: status.chunk is NULL in CHUNK_READ_EOF ReaderStatusUpdate. Ignoring update.";
continue;
}
Chunk* pChunk2 = m_chunksBeingRead.take(pChunk->chunk_number);
if (pChunk2 != pChunk) {
qDebug() << "Mismatch in requested chunk to read!";
}
freeChunk(pChunk);
} else if (status.status == CHUNK_READ_INVALID) {
qDebug() << "WARNING: READER THREAD RECEIVED INVALID CHUNK READ";
Chunk* pChunk = status.chunk;
if (pChunk == NULL) {
qDebug() << "ERROR: status.chunk is NULL in CHUNK_READ_INVALID ReaderStatusUpdate. Ignoring update.";
continue;
}
Chunk* pChunk2 = m_chunksBeingRead.take(pChunk->chunk_number);
if (pChunk2 != pChunk) {
qDebug() << "Mismatch in requested chunk to read!";
}
freeChunk(pChunk);
}
}
}
void ChunkCache::setChunk(PositionI chunkBasePosition, const std::vector<std::uint8_t> &buffer)
{
getDebugLog() << "stored chunk at " << chunkBasePosition << " with buffer of length " << buffer.size() << postnl;
std::unique_lock<std::mutex> lockIt(theLock);
static_assert(NullChunk == std::size_t(), "invalid value for NullChunk");
std::size_t &startingChunkIndex = startingChunksMap[chunkBasePosition];
std::size_t prevChunkIndex = NullChunk;
std::size_t bufferPos = 0;
while(bufferPos < buffer.size())
{
std::size_t chunkIndex;
if(prevChunkIndex == NullChunk)
chunkIndex = startingChunkIndex;
else
chunkIndex = fileChunks[prevChunkIndex].nextChunk;
if(chunkIndex == NullChunk)
{
chunkIndex = allocChunk();
if(prevChunkIndex == NullChunk)
startingChunkIndex = chunkIndex;
else
fileChunks[prevChunkIndex].nextChunk = chunkIndex;
}
prevChunkIndex = chunkIndex;
std::size_t currentChunkSize = chunkSize;
if(currentChunkSize > buffer.size() - bufferPos)
currentChunkSize = buffer.size() - bufferPos;
fileChunks[chunkIndex].usedSize = currentChunkSize;
bufferPos += currentChunkSize;
}
std::size_t freeChunkIndex;
if(prevChunkIndex == NullChunk)
{
freeChunkIndex = startingChunkIndex;
startingChunkIndex = NullChunk;
}
else
{
freeChunkIndex = fileChunks[prevChunkIndex].nextChunk;
fileChunks[prevChunkIndex].nextChunk = NullChunk;
}
while(freeChunkIndex != NullChunk)
{
std::size_t nextChunkIndex = fileChunks[freeChunkIndex].nextChunk;
freeChunk(freeChunkIndex);
freeChunkIndex = nextChunkIndex;
}
bufferPos = 0;
std::size_t chunkIndex = startingChunkIndex;
while(bufferPos < buffer.size())
{
assert(chunkIndex != NullChunk);
std::size_t currentChunkSize = chunkSize;
if(currentChunkSize > buffer.size() - bufferPos)
currentChunkSize = buffer.size() - bufferPos;
fileChunks[chunkIndex].usedSize = currentChunkSize;
try
{
static_assert(NullChunk == 0, "invalid value for NullChunk");
std::int64_t filePosition = static_cast<std::int64_t>(chunkIndex - 1) * chunkSize; // skip null chunk
writer->seek(filePosition, stream::SeekPosition::Start);
writer->writeBytes(&buffer[bufferPos], currentChunkSize);
}
catch(stream::IOException &e)
{
try
{
writer->flush();
}
catch(stream::IOException &)
{
}
throw e;
}
bufferPos += currentChunkSize;
chunkIndex = fileChunks[chunkIndex].nextChunk;
}
assert(chunkIndex == NullChunk);
writer->flush();
}
chunk *computeInstruction(ANTLR3_BASE_TREE *node) {
debug(DEBUG_GENERATION, "\033[22;93mCompute instruction\033[0m");
chunk *chunk, *tmp_chunk;
int i, scope_tmp;
static int scope = 0;
switch (node->getType(node)) {
case INTEGER :
case STRING :
case ID :
case FUNC_CALL :
case SUP :
case INF :
case SUP_EQ :
case INF_EQ :
case EQ :
case DIFF :
case AND :
case OR :
case MINUS :
case PLUS :
case DIV :
case MULT :
case NEG :
case ASSIGNE :
return computeExpr(node);
case IF:
return computeIf(node);
case WHILE :
return computeWhile(node);
case FOR :
return computeFor(node);
case VAR_DECLARATION :
return computeVarDeclaration(node);
case FUNC_DECLARATION :
case LET :
enterScopeN(scope);
scope_tmp = scope;
scope = 0;
switch (node->getType(node)) {
case LET:
chunk = computeLet(node);
break;
case FUNC_DECLARATION:
chunk = computeFuncDeclaration(node);
break;
}
scope = scope_tmp;
scope++;
leaveScope();
return chunk;
default:
chunk = initChunk();
// Compute all children
for (i = 0; i < node->getChildCount(node); i++) {
tmp_chunk = computeInstruction(node->getChild(node, i));
appendChunks(chunk, tmp_chunk);
// appendChunks replace chunk->registre with tmp_chunk's one
// but freeChunk free the registre of tmp_chunk
// we don't want chunk->registre to be overwritten !
if (tmp_chunk != NULL)
tmp_chunk->registre = -1;
freeChunk(tmp_chunk);
}
return chunk;
}
}
MySoundEffect::~MySoundEffect()
{
freeMusic();
freeChunk();
}
/* Reallocate memory. When we need more memory
* we allocate a piece of memory with an appropriate size,
* copy an old memory and then free it.
*/
void* reallocateMemory(
void* self,
MemoryContainer container,
void* old_mem,
size_t new_size)
{
IMemContainerManager _ = (IMemContainerManager)self;
IErrorLogger elog = _->errorLogger;
MemorySet set = (MemorySet)container;
MemoryChunk chunk = (MemoryChunk)((char*)old_mem - MEM_CHUNK_SIZE);
size_t oldsize = chunk->size;
void* chunkPtr;
void* new_mem;
/* Always return when a requested size is a decrease */
if (oldsize >= new_size)
return old_mem;
/* Check if for the chunk there was allocate a block */
if (oldsize > set->chunkMaxSize)
{
/* Try to find the corresponding block first
*/
MemoryBlock block = set->blockList;
MemoryBlock prevblock = NULL;
size_t chunk_size;
size_t block_size;
char* expected_block_end;
while (block != NULL)
{
if (chunk == (MemoryChunk)((char*)block + MEM_BLOCK_SIZE))
break;
prevblock = block;
block = block->next;
}
/* Could not find the block. We should report an error. */
if (block == NULL)
{
elog->log(LOG_ERROR,
ERROR_CODE_BLOCK_NOT_FOUND,
"Could not find block containing chunk %p",
chunk);
return NULL;
}
/* We should check that the chunk is only one
* on the block.
*/
expected_block_end = (char*)block +
chunk->size +
MEM_BLOCK_SIZE +
MEM_CHUNK_SIZE;
ASSERT(elog, block->freeEnd == expected_block_end, NULL);
/* Do the realloc */
chunk_size = AlignDefault(new_size);
block_size = chunk_size + MEM_BLOCK_SIZE + MEM_CHUNK_SIZE;
ASSERT(elog, funcRealloc != NULL, NULL);
block = (MemoryBlock)funcRealloc(block, block_size);
if (block == NULL)
{
showMemStat(_, topMemCont, 0);
elog->log(LOG_ERROR,
ERROR_CODE_OUT_OF_MEMORY,
"Out of memory. Failed request size: %lu",
block_size);
return NULL;
}
block->freeStart = block->freeEnd = (char*)block + block_size;
chunk = (MemoryChunk)((char*)block + MEM_BLOCK_SIZE);
/* Change block pointer to newly allocated block. */
if (prevblock == NULL)
set->blockList = block;
else
prevblock->next = block;
chunk->size = chunk_size;
chunkPtr = MemoryChunkGetPointer(chunk);
return chunkPtr;
}
/* If we are here that this small block
* was taken from the free list. We allocate
* a new free chunk and the old chunk add to
* the free list.
*/
new_mem = allocateMemory(_, container, new_size);
/* copy existing memory to a new memory. */
memcpy(new_mem, old_mem, oldsize);
/* free old chunk */
freeChunk(self, old_mem);
return new_mem;
}
