You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
189 lines
7.8 KiB
189 lines
7.8 KiB
$export_common #library "ZMEMORY"
|
|
$export_common #include "zcommon.acs"
|
|
|
|
#define muffins 42
|
|
|
|
$export_common #include "ZMEMORY_g.acs"
|
|
$export_common #include "ZMEMORY_w.acs"
|
|
|
|
//Simple linked list implementation of malloc
|
|
|
|
//$export_common global int 63:gmemory[];
|
|
//$export_common world int 255:wmemory[];
|
|
|
|
$export_option
|
|
global int 63:gmemory[];
|
|
$
|
|
world int 255:wmemory[];
|
|
$
|
|
|
|
$export_common #libdefine nullptr 0
|
|
|
|
$export_common //#define nullptr 0
|
|
|
|
$export_common #define malloc_allocated 0
|
|
$export_common #define malloc_size 1
|
|
$export_common #define malloc_next_header 2
|
|
$export_common #define malloc_prev_header 3
|
|
$export_common #define malloc_num_header_properties 4
|
|
|
|
$export_common #define p_malloc_init_flag_location 0
|
|
$export_common #define p_malloc_first_header_location 1
|
|
|
|
$$export_split
|
|
//[Z] The reason I do it like this is because whoever made the acc is insane.
|
|
#define @nullptr 0
|
|
|
|
#define @malloc_allocated 0
|
|
#define @malloc_size 1
|
|
#define @malloc_next_header 2
|
|
#define @malloc_prev_header 3
|
|
#define @malloc_num_header_properties 4
|
|
|
|
#define @p_malloc_init_flag_location 0
|
|
#define @p_malloc_first_header_location 1
|
|
$$
|
|
|
|
$$export_split function int @malloc (int size) {
|
|
//Do the setup on the first run of this function.
|
|
if(@memory[@p_malloc_init_flag_location] == FALSE) { //Default values for global values is 0, so this is true.
|
|
@memory[@p_malloc_init_flag_location] = TRUE;
|
|
@memory[@p_malloc_first_header_location+@malloc_allocated] = FALSE;
|
|
@memory[@p_malloc_first_header_location+@malloc_size] = -1; //"infinite"
|
|
@memory[@p_malloc_first_header_location+@malloc_next_header] = @nullptr; //nullptr
|
|
@memory[@p_malloc_first_header_location+@malloc_prev_header] = @nullptr; //nullptr
|
|
}
|
|
|
|
int p_previous_header = @nullptr;
|
|
int p_current_header = @p_malloc_first_header_location;
|
|
int p_retval = @nullptr;
|
|
|
|
while(p_retval == @nullptr) {
|
|
int memalloced = @memory[p_current_header+@malloc_allocated];
|
|
int memsize = @memory[p_current_header+@malloc_size];
|
|
if(memsize == -1) { //The end of the list.
|
|
@memory[p_current_header+@malloc_allocated] = TRUE;
|
|
@memory[p_current_header+@malloc_size] = size;
|
|
@memory[p_current_header+@malloc_next_header] = p_current_header+@malloc_num_header_properties+size; //New EOL
|
|
@memory[p_current_header+@malloc_prev_header] = p_previous_header;
|
|
|
|
//Retrieve the return value while we are at the allocated space.
|
|
p_retval = p_current_header+@malloc_num_header_properties;
|
|
|
|
//Remember to initialize the new end list node.
|
|
p_previous_header = p_current_header; //This is the header previous to the EOL.
|
|
p_current_header = @memory[p_current_header+@malloc_next_header];
|
|
//Set the tail node constants.
|
|
@memory[p_current_header+@malloc_allocated] = FALSE;
|
|
@memory[p_current_header+@malloc_size] = -1;
|
|
@memory[p_current_header+@malloc_next_header] = @nullptr;
|
|
@memory[p_current_header+@malloc_prev_header] = p_previous_header;
|
|
} else if(memsize >= size && memalloced == FALSE) { //There is room here AND it isn't in use,
|
|
@memory[p_current_header+@malloc_allocated] = TRUE;
|
|
//The size isn't modified because we are re-using an existing space.
|
|
// It would be a good idea to check just how large this space is and act accordingly rather
|
|
// than using a 500 indexes large space for a 4 indexes large object.
|
|
// Objects allocated in a doom mod probably won't be outside the 1-16 indexes range so it
|
|
// should still be fine for most applications.
|
|
//The next header isn't changed either for the same reason.
|
|
if(memsize >= (size+@malloc_num_header_properties+5)) { //Assume that 5 is the smallest useful allocation size.
|
|
int p_split_newheader = p_current_header+@malloc_num_header_properties+size; //Just to the end of the allocation.
|
|
@memory[p_split_newheader+@malloc_allocated] = FALSE;
|
|
@memory[p_split_newheader+@malloc_size] = @memory[p_current_header+@malloc_size]-@malloc_num_header_properties-size;
|
|
@memory[p_split_newheader+@malloc_next_header] = @memory[p_current_header+@malloc_next_header];
|
|
@memory[p_split_newheader+@malloc_prev_header] = p_current_header;
|
|
@memory[p_current_header+@malloc_next_header] = p_split_newheader; //The header whose block was split should have its next pointer set to its other half.
|
|
@memory[p_current_header+@malloc_size] = size; //Set the size of the allocation to reflect the split.
|
|
}
|
|
|
|
//Retrieve the return value while we are at the allocated space.
|
|
p_retval = p_current_header+@malloc_num_header_properties;
|
|
} else {
|
|
//The observed node isn't useful for allocating the request. Go to the next node.
|
|
p_previous_header = p_current_header;
|
|
p_current_header = @memory[p_current_header+@malloc_next_header];
|
|
}
|
|
}
|
|
|
|
//log(s:"Malloc allocated ", d:size, s:" indexes at location ", d:p_retval, s:" with header location ", d:p_current_header);
|
|
|
|
return p_retval;
|
|
}
|
|
$$
|
|
|
|
$$export_split function int @free (int p_ptr) {
|
|
log(s:"Invoked free");
|
|
|
|
int p_header = p_ptr - @malloc_num_header_properties;
|
|
|
|
@memory[p_header+@malloc_allocated] = FALSE;
|
|
|
|
int p_next = @memory[p_header+@malloc_next_header];
|
|
int p_prev = @memory[p_header+@malloc_prev_header];
|
|
|
|
//Below is the merging of free blocks.
|
|
//It merges to the left (lower indexes) first becaue the right (larger
|
|
// indexes) has a special case. (the end of the list)
|
|
|
|
//the previous block is unused. Merge.
|
|
if(p_prev != @nullptr //This doesn't make sense if the previous block doesn't exist.
|
|
&& @memory[p_prev+@malloc_allocated] == FALSE) {
|
|
log(s:"Free attempting merge of header ", d:p_header, s: " to the left with header ", d:p_prev);
|
|
@memory[p_prev+@malloc_size] += @memory[p_header+@malloc_size] + @malloc_num_header_properties;
|
|
@memory[p_prev+@malloc_next_header] = p_next; //The prev header needs to know the new next.
|
|
@memory[p_next+@malloc_prev_header] = p_prev; //The next header needs to know the new prev.
|
|
|
|
//Now the two blocks are the same block. requires new initializations of the
|
|
// variables for the other check to function correctly.
|
|
//The header is the result of the merge, and the prev is the one before it.
|
|
p_header = p_prev;
|
|
p_prev = @memory[p_header+@malloc_prev_header];
|
|
}
|
|
|
|
//The next block is unused. Merge.
|
|
//Note that p_next will never be a nullptr with correct usage.
|
|
if(@memory[p_next+@malloc_allocated] == FALSE) {
|
|
if(@memory[p_next+@malloc_size] == -1) { //EOL
|
|
@memory[p_header+@malloc_size] = -1;
|
|
@memory[p_header+@malloc_next_header] = @nullptr;
|
|
} else {
|
|
int p_next_next = @memory[p_next+@malloc_next_header];
|
|
@memory[p_header+@malloc_size] += @memory[p_next+@malloc_size] + @malloc_num_header_properties;
|
|
@memory[p_header+@malloc_next_header] = p_next_next; //The header on the other side of the next header needs to know its new prev.
|
|
@memory[p_next_next+@malloc_prev_header] = p_header; //This header needs to know its new next.
|
|
}
|
|
}
|
|
|
|
|
|
return -1;
|
|
}
|
|
$$
|
|
|
|
|
|
//These are for debugging
|
|
/*
|
|
script "memory_write" (int index, int value) {
|
|
memory[index] = value;
|
|
}
|
|
|
|
script "memory_read" (int index) {
|
|
log(d:memory[index]);
|
|
}
|
|
|
|
script "memory_print_allocation_list" (void) {
|
|
int p_current_header = p_malloc_first_header_location;
|
|
|
|
while(p_current_header != nullptr) {
|
|
log(s: "Header location: ", d:p_current_header,
|
|
s:"\n Allocated flag: ", d:memory[p_current_header+malloc_allocated],
|
|
s:"\n Allocation size: ", d:memory[p_current_header+malloc_size],
|
|
s:"\n Prev header pointer: ", d:memory[p_current_header+malloc_prev_header],
|
|
s:"\n Next header pointer: ", d:memory[p_current_header+malloc_next_header],
|
|
s:"\n"
|
|
);
|
|
|
|
p_current_header = memory[p_current_header+malloc_next_header];
|
|
}
|
|
}
|
|
*/
|
|
|