void
LRMI_free_real(void *m)
{
int i;
char *r = (char *)REAL_MEM_BASE;
if (!mem_info.ready)
return;
i = 0;
while (m != (void *)r) {
r += mem_info.blocks[i].size;
i++;
if (i == mem_info.count)
return;
}
mem_info.blocks[i].free = 1;
if (i + 1 < mem_info.count && mem_info.blocks[i + 1].free) {
mem_info.blocks[i].size += mem_info.blocks[i + 1].size;
delete_block(i + 1);
}
if (i - 1 >= 0 && mem_info.blocks[i - 1].free) {
mem_info.blocks[i - 1].size += mem_info.blocks[i].size;
delete_block(i);
}
}
void BlockManager::deallocate_local(const BlockId& id) {
if (has_wild_value(id)) {
std::vector<BlockId> list;
generate_local_block_list(id, list);
std::vector<BlockId>::iterator it;
for (it = list.begin(); it != list.end(); ++it) {
delete_block(*it);
}
} else {
delete_block(id);
}
}
main_pool::~main_pool()
{
for (auto & it : used_blocks)
{
delete_block(it);
}
}
static void
apply_action( void *data, void *user_data )
{
const action_t *action = data;
libspectrum_rzx *rzx = user_data;
int where = action->where;
switch( action->type ) {
case ACTION_DELETE_BLOCK:
delete_block( rzx, where );
break;
case ACTION_EXTRACT_SNAP:
extract_snap( rzx, where, action->filename );
break;
case ACTION_INSERT_SNAP:
insert_snap( rzx, where, action->filename );
break;
case ACTION_FINALISE_RZX:
libspectrum_rzx_finalise( rzx );
break;
default:
fprintf( stderr, "%s: unknown action type %d\n", progname, action->type );
}
/* Really would like to handle errors */
}
super_block_cache::~super_block_cache()
{
for (size_t index = 0; index < BIN_SIZES_COUNT; ++index)
{
for (auto & it : blocks[index])
{
delete_block(it);
}
}
}
/*
* split - handle splitting of a free block during allocation
*/
static void *split(void *bp, size_t asize) {
size_t original_size = GET_SIZE(HDRP(bp));
void *split_block;
/* Split the free block before allocation */
if (original_size >= asize + MIN_SIZE) {
/* Update size */
delete_block(bp);
set_size(bp, asize);
/* Set split_block size and add to free list */
split_block = NEXT_BLKP(bp);
set_size(split_block, original_size - asize);
add_block(split_block);
} else {
delete_block(bp);
}
/* Allocate the entire free block if not splitting */
return bp;
}
/*
* coalesce - Boundary tag coalescing. Return ptr to coalesced block
*/
static void *coalesce(void *bp)
{
void *prev = PREV_BLKP(bp);
void *next = NEXT_BLKP(bp);
size_t prev_alloc = GET_ALLOC(HDRP(prev));
size_t next_alloc = GET_ALLOC(HDRP(next));
size_t size = GET_SIZE(HDRP(bp));
if (prev_alloc && next_alloc) { /* Case 1 */
add_block(bp);
return bp;
}
else if (prev_alloc && !next_alloc) { /* Case 2 */
delete_block(next);
size += GET_SIZE(HDRP(next));
set_size(bp, size);
add_block(bp);
return bp;
}
else if (!prev_alloc && next_alloc) { /* Case 3 */
delete_block(prev);
size += GET_SIZE(HDRP(prev));
set_size(prev, size);
add_block(prev);
return prev;
}
else { /* Case 4 */
delete_block(next);
delete_block(prev);
size += GET_SIZE(HDRP(prev)) +
GET_SIZE(HDRP(next));
set_size(prev, size);
add_block(prev);
return prev;
}
}
/*removes the temp blocks in the current scope, then delete the scope's TempBlockStack */
void BlockManager::leave_scope() {
BlockList* temps = temp_block_list_stack_.back();
BlockList::iterator it;
for (it = temps->begin(); it != temps->end(); ++it) {
BlockId &block_id = *it;
int array_id = block_id.array_id();
// Cached delete for distributed/served arrays.
// Regular delete for temp blocks.
if (sip_tables_.is_distributed(array_id) || sip_tables_.is_served(array_id))
cached_delete_block(*it);
else
delete_block(*it);
// delete_block(*it);
}
temp_block_list_stack_.pop_back();
delete temps;
}
