Max/nunuhara_xsystem4
1
0
Fork 0
mirror of https://github.com/nunuhara/xsystem4.git synced 2026-09-30 19:08:12 +03:00
Code Issues Packages Projects Releases Wiki Activity

Move heap management code into heap.c

Browse Source
This commit is contained in:
Nunuhara Cabbage
2019-12-23 16:53:00 -08:00
parent 9bb1d0ec0b
commit eb8c7b0fe6
12 changed files with 219 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files
debugger.c
+3 -2
View File
@@ -17,9 +17,10 @@
#include <stdio.h>
#include <chibi/eval.h>
#include "vm.h"
#include "heap.h"
#include "page.h"
#include "utfsjis.h"
#include "vm.h"
struct variable {
enum ain_data_type data_type;
@@ -49,7 +50,7 @@ static struct page *get_page(int pageno)
{
if (!page_index_valid(pageno))
return NULL;
return vm_get_page(pageno);
return heap_get_page(pageno);
}
static struct variable *get_global_by_name(const char *name)
heap.c
+142
View File
@@ -0,0 +1,142 @@
/* Copyright (C) 2019 Nunuhara Cabbage <nunuhara@haniwa.technology>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://gnu.org/licenses/>.
*/
#include <stdlib.h>
#include "page.h"
#include "heap.h"
#include "vm.h"
#define INITIAL_HEAP_SIZE 4096
#define HEAP_ALLOC_STEP 4096
struct vm_pointer *heap;
static size_t heap_size;
// Heap free list
// This is a list of unused indices into the 'heap' array.
static int32_t *heap_free_stack;
static size_t heap_free_ptr = 0;
static const char *vm_ptrtype_strtab[] = {
[VM_PAGE] = "VM_PAGE",
[VM_STRING] = "VM_STRING",
};
static const char *vm_ptrtype_string(enum vm_pointer_type type) {
if (type < NR_VM_POINTER_TYPES)
return vm_ptrtype_strtab[type];
return "INVALID POINTER TYPE";
}
void heap_init(void)
{
heap_size = INITIAL_HEAP_SIZE;
heap = xmalloc(INITIAL_HEAP_SIZE * sizeof(struct vm_pointer));
heap_free_stack = xmalloc(INITIAL_HEAP_SIZE * sizeof(int32_t));
for (size_t i = 0; i < INITIAL_HEAP_SIZE; i++) {
heap_free_stack[i] = i;
}
heap_free_ptr = 1; // global page at index 0
}
int32_t heap_alloc_slot(enum vm_pointer_type type)
{
// grow heap if needed
if (heap_free_ptr >= heap_size) {
heap = xrealloc(heap, sizeof(struct vm_pointer) * (heap_size+HEAP_ALLOC_STEP));
heap_free_stack = xrealloc(heap_free_stack, sizeof(int32_t) * (heap_size+HEAP_ALLOC_STEP));
for (size_t i = heap_size; i < heap_size+HEAP_ALLOC_STEP; i++) {
heap_free_stack[i] = i;
}
heap_size += HEAP_ALLOC_STEP;
}
int32_t slot = heap_free_stack[heap_free_ptr++];
heap[slot].ref = 1;
heap[slot].type = type;
#ifdef DEBUG_HEAP
heap[slot].alloc_addr = instr_ptr;
heap[slot].ref_addr = 0;
#endif
return slot;
}
static void heap_free_slot(int32_t slot)
{
heap_free_stack[--heap_free_ptr] = slot;
}
void heap_ref(int32_t slot)
{
if (slot == -1)
return;
heap[slot].ref++;
#ifdef DEBUG_HEAP
heap[slot].ref_addr = instr_ptr;
#endif
}
void heap_unref(int slot)
{
if (heap[slot].ref <= 0) {
#ifdef DEBUG_HEAP
VM_ERROR("double free of slot %d (%s)\nOriginally allocated at %X\nOriginally freed at %X",
slot, vm_ptrtype_string(heap[slot].type), heap[slot].alloc_addr, heap[slot].free_addr);
#endif
VM_ERROR("double free of slot %d (%s)", slot, vm_ptrtype_string(heap[slot].type));
}
if (--heap[slot].ref <= 0) {
#ifdef DEBUG_HEAP
heap[slot].free_addr = instr_ptr;
#endif
switch (heap[slot].type) {
case VM_PAGE:
if (heap[slot].page) {
delete_page(heap[slot].page);
free_page(heap[slot].page);
}
break;
case VM_STRING:
free_string(heap[slot].s);
break;
}
heap_free_slot(slot);
}
}
bool heap_index_valid(int index)
{
return index >= 0 && (size_t)index < heap_size && heap[index].ref > 0;
}
bool page_index_valid(int index)
{
return heap_index_valid(index) && heap[index].type == VM_PAGE;
}
struct page *heap_get_page(int index)
{
if (!page_index_valid(index))
VM_ERROR("Invalid page index: %d", index);
return heap[index].page;
}
void heap_set_page(int slot, struct page *page)
{
heap[slot].page = page;
}
heap.h
+56
View File
@@ -0,0 +1,56 @@
/* Copyright (C) 2019 Nunuhara Cabbage <nunuhara@haniwa.technology>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://gnu.org/licenses/>.
*/
#ifndef SYSTEM4_HEAP_H
#define SYSTEM4_HEAP_H
#include <stdint.h>
struct string;
struct page;
enum vm_pointer_type {
VM_PAGE,
VM_STRING
};
#define NR_VM_POINTER_TYPES (VM_STRING+1)
// Heap-backed objects. Reference counted.
struct vm_pointer {
int ref;
enum vm_pointer_type type;
union {
struct string *s;
struct page *page;
};
#ifdef DEBUG_HEAP
size_t alloc_addr;
size_t ref_addr;
size_t free_addr;
#endif
};
struct vm_pointer *heap;
void heap_init(void);
int32_t heap_alloc_slot(enum vm_pointer_type type);
void heap_ref(int slot);
void heap_unref(int slot);
struct page *heap_get_page(int index);
void heap_set_page(int slot, struct page *page);
#endif /* SYSTEM4_HEAP_H */
hll/File.c
+2 -1
View File
@@ -21,6 +21,7 @@
#include <sys/stat.h>
#include "hll.h"
#include "../file.h"
#include "../heap.h"
#include "../savedata.h"
#include "../system4.h"
@@ -73,7 +74,7 @@ hll_defun(Close, args)
//int Read(ref struct pIVMStruct)
hll_defun(Read, args)
{
struct page *page = vm_get_page(args[0].i);
struct page *page = heap_get_page(args[0].i);
if (page->type != STRUCT_PAGE) {
VM_ERROR("File.Read of non-struct");
}
hll/hll.h
+1
View File
@@ -22,6 +22,7 @@
*/
#include "../vm.h"
#include "../heap.h"
#include "../page.h"
#include "../system4.h"
meson.build
+1
View File
@@ -13,6 +13,7 @@ xsystem4 = ['ald.c',
'cg.c',
'draw.c',
'file.c',
'heap.c',
'ini.c',
'input.c',
'page.c',
page.c
+2 -1
View File
@@ -16,9 +16,10 @@
#include "system4.h"
#include "ain.h"
#include "heap.h"
#include "page.h"
#include "vm.h"
#include "vm_string.h"
#include "page.h"
#define NR_CACHES 8
#define CACHE_SIZE 64
page.h
+1 -11
View File
@@ -19,8 +19,8 @@
#include <stdbool.h>
#include <stdint.h>
#include "vm.h"
#include "ain.h"
#include "vm.h"
struct ain_variable;
enum ain_data_type;
@@ -61,16 +61,6 @@ struct page {
union vm_value values[];
};
static inline union vm_value page_get(int pageno, int varno)
{
return heap[pageno].page->values[varno];
}
static inline void page_set(int pageno, int varno, union vm_value v)
{
heap[pageno].page->values[varno] = v;
}
// variables
union vm_value variable_initval(enum ain_data_type type);
void variable_fini(union vm_value v, enum ain_data_type type);
savedata.c
+5 -4
View File
@@ -18,11 +18,12 @@
#include <string.h>
#include <errno.h>
#include "system4.h"
#include "savedata.h"
#include "ain.h"
#include "page.h"
#include "vm.h"
#include "cJSON.h"
#include "heap.h"
#include "page.h"
#include "savedata.h"
#include "vm.h"
static int current_global;
@@ -44,7 +45,7 @@ static char *savedir_path(const char *filename)
static cJSON *page_to_json(int index)
{
struct page *page = vm_get_page(index);
struct page *page = heap_get_page(index);
if (!page)
return cJSON_CreateNull();
string.c
+2 -1
View File
@@ -18,10 +18,11 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "heap.h"
#include "system4.h"
#include "utfsjis.h"
#include "vm.h"
#include "vm_string.h"
#include "utfsjis.h"
struct string EMPTY_STRING = {
.cow = true,
vm.c
+3 -114
View File
@@ -26,6 +26,7 @@
#include "page.h"
#include "ain.h"
#include "file.h"
#include "heap.h"
#include "instructions.h"
#include "little_endian.h"
#include "savedata.h"
@@ -33,8 +34,6 @@
#include "debugger.h"
#define INITIAL_STACK_SIZE 4096
#define INITIAL_HEAP_SIZE 4096
#define HEAP_ALLOC_STEP 4096
#define HLL_MAX_ARGS 64
// When the IP is set to VM_RETURN, the VM halts
@@ -57,16 +56,6 @@ union vm_value *stack = NULL; // the stack
int32_t stack_ptr = 0; // pointer to the top of the stack
static size_t stack_size; // current size of the stack
// The heap
// An array of pointers to heap-allocated objects, plus reference counts.
struct vm_pointer *heap;
static size_t heap_size;
// Heap free list
// This is a list of unused indices into the 'heap' array.
static int32_t *heap_free_stack;
static size_t heap_free_ptr = 0;
// Stack of function call frames
static struct function_call call_stack[4096];
static int32_t call_stack_ptr = 0; // 0 = imaginary frame before main()
@@ -102,87 +91,6 @@ static const char *current_instruction_name(void)
return "UNKNOWN OPCODE";
}
int32_t heap_alloc_slot(enum vm_pointer_type type)
{
// grow heap if needed
if (heap_free_ptr >= heap_size) {
heap = xrealloc(heap, sizeof(struct vm_pointer) * (heap_size+HEAP_ALLOC_STEP));
heap_free_stack = xrealloc(heap_free_stack, sizeof(int32_t) * (heap_size+HEAP_ALLOC_STEP));
for (size_t i = heap_size; i < heap_size+HEAP_ALLOC_STEP; i++) {
heap_free_stack[i] = i;
}
heap_size += HEAP_ALLOC_STEP;
}
int32_t slot = heap_free_stack[heap_free_ptr++];
heap[slot].ref = 1;
heap[slot].type = type;
#ifdef DEBUG_HEAP
heap[slot].alloc_addr = instr_ptr;
heap[slot].ref_addr = 0;
#endif
return slot;
}
static void heap_free_slot(int32_t slot)
{
heap_free_stack[--heap_free_ptr] = slot;
}
void heap_ref(int32_t slot)
{
if (slot == -1)
return;
heap[slot].ref++;
#ifdef DEBUG_HEAP
heap[slot].ref_addr = instr_ptr;
#endif
}
static const char *vm_ptrtype_strtab[] = {
[VM_PAGE] = "VM_PAGE",
[VM_STRING] = "VM_STRING",
};
static const char *vm_ptrtype_string(enum vm_pointer_type type) {
if (type < NR_VM_POINTER_TYPES)
return vm_ptrtype_strtab[type];
return "INVALID POINTER TYPE";
}
void heap_unref(int slot)
{
if (heap[slot].ref <= 0) {
#ifdef DEBUG_HEAP
VM_ERROR("double free of slot %d (%s)\nOriginally allocd at %X\nOriginally freed at %X",
slot, vm_ptrtype_string(heap[slot].type), heap[slot].alloc_addr, heap[slot].free_addr);
#endif
VM_ERROR("double free of slot %d (%s)", slot, vm_ptrtype_string(heap[slot].type));
}
if (--heap[slot].ref <= 0) {
#ifdef DEBUG_HEAP
heap[slot].free_addr = instr_ptr;
#endif
switch (heap[slot].type) {
case VM_PAGE:
if (heap[slot].page) {
delete_page(heap[slot].page);
free_page(heap[slot].page);
}
break;
case VM_STRING:
free_string(heap[slot].s);
break;
}
heap_free_slot(slot);
}
}
void heap_set_page(int slot, struct page *page)
{
heap[slot].page = page;
}
static int local_page_slot(void)
{
return call_stack[call_stack_ptr-1].page_slot;
@@ -238,18 +146,6 @@ static union vm_value *struct_page(void)
return heap[struct_page_slot()].page->values;
}
bool page_index_valid(int index)
{
return index >= 0 && (size_t)index < heap_size && heap[index].ref > 0 && heap[index].type == VM_PAGE;
}
struct page *vm_get_page(int index)
{
if (!page_index_valid(index))
VM_ERROR("Invalid page index: %d", index);
return heap[index].page;
}
static union vm_value stack_peek(int n)
{
return stack[stack_ptr - (1 + n)];
@@ -271,7 +167,7 @@ static union vm_value *stack_pop_var(void)
{
int32_t page_index = stack_pop().i;
int32_t heap_index = stack_pop().i;
if (heap_index < 0 || (size_t)heap_index >= heap_size)
if (!heap_index_valid(heap_index))
VM_ERROR("Out of bounds heap index: %d/%d", heap_index, page_index);
if (!heap[heap_index].page || page_index >= heap[heap_index].page->nr_vars)
VM_ERROR("Out of bounds page index: %d/%d", heap_index, page_index);
@@ -1705,14 +1601,7 @@ void vm_execute_ain(struct ain *program)
stack = xmalloc(INITIAL_STACK_SIZE * sizeof(union vm_value));
stack_ptr = 0;
heap_size = INITIAL_HEAP_SIZE;
heap = xmalloc(INITIAL_HEAP_SIZE * sizeof(struct vm_pointer));
heap_free_stack = xmalloc(INITIAL_HEAP_SIZE * sizeof(int32_t));
for (size_t i = 0; i < INITIAL_HEAP_SIZE; i++) {
heap_free_stack[i] = i;
}
heap_free_ptr = 1; // global page at index 0
heap_init();
ain = program;
vm.h
+1 -30
View File
@@ -32,32 +32,10 @@ union vm_value {
float *fref;
};
enum vm_pointer_type {
VM_PAGE,
VM_STRING
};
#define NR_VM_POINTER_TYPES (VM_STRING+1)
struct string;
struct page;
enum ain_data_type;
// Heap-backed objects. Reference counted.
struct vm_pointer {
int ref;
enum vm_pointer_type type;
union {
struct string *s;
struct page *page;
};
#ifdef DEBUG_HEAP
size_t alloc_addr;
size_t ref_addr;
size_t free_addr;
#endif
};
struct hll_function {
char *name;
union vm_value (*fun)(union vm_value *_args);
@@ -70,15 +48,10 @@ struct library {
struct ain;
struct vm_pointer *heap;
union vm_value *stack;
int32_t stack_ptr;
struct ain *ain;
int32_t heap_alloc_slot(enum vm_pointer_type type);
void heap_ref(int slot);
void heap_unref(int slot);
static inline union vm_value _vm_id(union vm_value v)
{
return v;
@@ -126,12 +99,10 @@ static inline void stack_push_value(union vm_value v)
#define stack_push(v) (stack_push_value(vm_value_cast(v)))
union vm_value stack_pop(void);
void heap_set_page(int slot, struct page *page);
union vm_value global_get(int varno);
void global_set(int varno, union vm_value val);
bool heap_index_valid(int index);
bool page_index_valid(int index);
struct page *vm_get_page(int index);
struct page *local_page(void);
int vm_string_ref(struct string *s);