Open-Argon/Chloride
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

change to dispatch table to hopefully improve speed

Browse Source
This commit is contained in:
William Bell
2025-08-29 12:22:35 +01:00
parent f598c215e7
commit 0f0a3f5d31
2 changed files with 188 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

344
src/runtime/runtime.c
View File

@@ -10,9 +10,9 @@
#include "../parser/number/number.h" #include "../parser/number/number.h"
#include "../translator/translator.h" #include "../translator/translator.h"
#include "access/access.h" #include "access/access.h"
#include "assignment/assignment.h"
#include "call/call.h" #include "call/call.h"
#include "declaration/declaration.h" #include "declaration/declaration.h"
#include "assignment/assignment.h"
#include "internals/hashmap/hashmap.h" #include "internals/hashmap/hashmap.h"
#include "objects/functions/functions.h" #include "objects/functions/functions.h"
#include "objects/literals/literals.h" #include "objects/literals/literals.h"
@@ -70,8 +70,9 @@ ArgonObject *ARGON_ADDITION_FUNCTION(size_t argc, ArgonObject **argv,
ArgonObject *ARGON_SUBTRACTION_FUNCTION(size_t argc, ArgonObject **argv, ArgonObject *ARGON_SUBTRACTION_FUNCTION(size_t argc, ArgonObject **argv,
ArErr *err, RuntimeState *state) { ArErr *err, RuntimeState *state) {
if (argc < 1) { if (argc < 1) {
*err = create_err(0, 0, 0, "", "Runtime Error", *err =
"subtract expects at least 1 argument, got %" PRIu64, argc); create_err(0, 0, 0, "", "Runtime Error",
"subtract expects at least 1 argument, got %" PRIu64, argc);
return ARGON_NULL; return ARGON_NULL;
} }
ArgonObject *output = argv[0]; ArgonObject *output = argv[0];
@@ -93,10 +94,11 @@ ArgonObject *ARGON_SUBTRACTION_FUNCTION(size_t argc, ArgonObject **argv,
} }
ArgonObject *ARGON_MULTIPLY_FUNCTION(size_t argc, ArgonObject **argv, ArgonObject *ARGON_MULTIPLY_FUNCTION(size_t argc, ArgonObject **argv,
ArErr *err, RuntimeState *state) { ArErr *err, RuntimeState *state) {
if (argc < 1) { if (argc < 1) {
*err = create_err(0, 0, 0, "", "Runtime Error", *err =
"multiply expects at least 1 argument, got %" PRIu64, argc); create_err(0, 0, 0, "", "Runtime Error",
"multiply expects at least 1 argument, got %" PRIu64, argc);
return ARGON_NULL; return ARGON_NULL;
} }
ArgonObject *output = argv[0]; ArgonObject *output = argv[0];
@@ -118,10 +120,11 @@ ArgonObject *ARGON_MULTIPLY_FUNCTION(size_t argc, ArgonObject **argv,
} }
ArgonObject *ARGON_DIVISION_FUNCTION(size_t argc, ArgonObject **argv, ArgonObject *ARGON_DIVISION_FUNCTION(size_t argc, ArgonObject **argv,
ArErr *err, RuntimeState *state) { ArErr *err, RuntimeState *state) {
if (argc < 1) { if (argc < 1) {
*err = create_err(0, 0, 0, "", "Runtime Error", *err =
"division expects at least 1 argument, got %" PRIu64, argc); create_err(0, 0, 0, "", "Runtime Error",
"division expects at least 1 argument, got %" PRIu64, argc);
return ARGON_NULL; return ARGON_NULL;
} }
ArgonObject *output = argv[0]; ArgonObject *output = argv[0];
@@ -337,24 +340,25 @@ ArgonObject *ARGON_STRING_TYPE___add__(size_t argc, ArgonObject **argv,
if (argv[1]->type != TYPE_STRING) { if (argv[1]->type != TYPE_STRING) {
ArgonObject *type_name = get_field_for_class( ArgonObject *type_name = get_field_for_class(
get_field(argv[1], "__class__", false, false), "__name__", argv[1]); get_field(argv[1], "__class__", false, false), "__name__", argv[1]);
*err = create_err(0, 0, 0, "", "Runtime Error", *err = create_err(
"__add__ cannot perform concatenation between a string and %.*s", 0, 0, 0, "", "Runtime Error",
type_name->value.as_str.length, "__add__ cannot perform concatenation between a string and %.*s",
type_name->value.as_str.data); type_name->value.as_str.length, type_name->value.as_str.data);
return ARGON_NULL; return ARGON_NULL;
} }
size_t length = argv[0]->value.as_str.length+argv[1]->value.as_str.length; size_t length = argv[0]->value.as_str.length + argv[1]->value.as_str.length;
char*concat = malloc(length); char *concat = malloc(length);
memcpy(concat,argv[0]->value.as_str.data, argv[0]->value.as_str.length); memcpy(concat, argv[0]->value.as_str.data, argv[0]->value.as_str.length);
memcpy(concat+argv[0]->value.as_str.length,argv[1]->value.as_str.data, argv[1]->value.as_str.length); memcpy(concat + argv[0]->value.as_str.length, argv[1]->value.as_str.data,
ArgonObject* object = new_string_object(concat, length); argv[1]->value.as_str.length);
ArgonObject *object = new_string_object(concat, length);
free(concat); free(concat);
return object; return object;
} }
ArgonObject *ARGON_BOOL_TYPE___string__(size_t argc, ArgonObject **argv, ArgonObject *ARGON_BOOL_TYPE___string__(size_t argc, ArgonObject **argv,
ArErr *err, RuntimeState *state) { ArErr *err, RuntimeState *state) {
(void)state; (void)state;
if (argc != 1) { if (argc != 1) {
*err = create_err(0, 0, 0, "", "Runtime Error", *err = create_err(0, 0, 0, "", "Runtime Error",
"__string__ expects 1 arguments, got %" PRIu64, argc); "__string__ expects 1 arguments, got %" PRIu64, argc);
@@ -366,7 +370,7 @@ ArgonObject *ARGON_BOOL_TYPE___string__(size_t argc, ArgonObject **argv,
ArgonObject *ARGON_BOOL_TYPE___number__(size_t argc, ArgonObject **argv, ArgonObject *ARGON_BOOL_TYPE___number__(size_t argc, ArgonObject **argv,
ArErr *err, RuntimeState *state) { ArErr *err, RuntimeState *state) {
(void)state; (void)state;
if (argc != 1) { if (argc != 1) {
*err = create_err(0, 0, 0, "", "Runtime Error", *err = create_err(0, 0, 0, "", "Runtime Error",
"__number__ expects 1 arguments, got %" PRIu64, argc); "__number__ expects 1 arguments, got %" PRIu64, argc);
@@ -519,9 +523,8 @@ void bootstrap_types() {
add_field( add_field(
ARGON_STRING_TYPE, "__init__", ARGON_STRING_TYPE, "__init__",
create_argon_native_function("__init__", ARGON_STRING_TYPE___init__)); create_argon_native_function("__init__", ARGON_STRING_TYPE___init__));
add_field( add_field(ARGON_STRING_TYPE, "__add__",
ARGON_STRING_TYPE, "__add__", create_argon_native_function("__add__", ARGON_STRING_TYPE___add__));
create_argon_native_function("__add__", ARGON_STRING_TYPE___add__));
add_field( add_field(
ARGON_STRING_TYPE, "__number__", ARGON_STRING_TYPE, "__number__",
create_argon_native_function("__number__", ARGON_STRING_TYPE___number__)); create_argon_native_function("__number__", ARGON_STRING_TYPE___number__));
@@ -597,19 +600,7 @@ int compare_by_order(const void *a, const void *b) {
return itemA->order - itemB->order; return itemA->order - itemB->order;
} }
uint8_t pop_byte(Translated *translated, RuntimeState *state) { static inline void load_const(Translated *translated, RuntimeState *state) {
return *((uint8_t *)darray_get(&translated->bytecode, state->head++));
}
uint64_t pop_bytecode(Translated *translated, RuntimeState *state) {
uint64_t value = 0;
for (int i = 0; i < 8; i++) {
value |= ((uint64_t)pop_byte(translated, state)) << (i * 8);
}
return value;
}
void load_const(Translated *translated, RuntimeState *state) {
uint64_t to_register = pop_byte(translated, state); uint64_t to_register = pop_byte(translated, state);
size_t length = pop_bytecode(translated, state); size_t length = pop_bytecode(translated, state);
uint64_t offset = pop_bytecode(translated, state); uint64_t offset = pop_bytecode(translated, state);
@@ -636,8 +627,8 @@ uint64_t runtime_hash(const void *data, size_t len, uint64_t prehash) {
return hash; return hash;
} }
ArErr load_variable(Translated *translated, RuntimeState *state, static inline ArErr load_variable(Translated *translated, RuntimeState *state,
struct Stack *stack) { struct Stack *stack) {
int64_t length = pop_bytecode(translated, state); int64_t length = pop_bytecode(translated, state);
int64_t offset = pop_bytecode(translated, state); int64_t offset = pop_bytecode(translated, state);
uint64_t prehash = pop_bytecode(translated, state); uint64_t prehash = pop_bytecode(translated, state);
@@ -660,137 +651,154 @@ ArErr load_variable(Translated *translated, RuntimeState *state,
return err; return err;
} }
ArErr run_instruction(Translated *translated, RuntimeState *state, static inline ArErr run_instruction(Translated *translated, RuntimeState *state,
struct Stack **stack) { struct Stack **stack) {
OperationType opcode = pop_byte(translated, state); static void *dispatch_table[] = {
switch (opcode) { [OP_LOAD_STRING] = &&DO_LOAD_STRING,
case OP_LOAD_NULL: [OP_DECLARE] = &&DO_DECLARE,
state->registers[pop_byte(translated, state)] = ARGON_NULL; [OP_LOAD_NULL] = &&DO_LOAD_NULL,
break; [OP_LOAD_FUNCTION] = &&DO_LOAD_FUNCTION,
case OP_LOAD_STRING: [OP_IDENTIFIER] = &&DO_IDENTIFIER,
load_const(translated, state); [OP_BOOL] = &&DO_BOOL,
break; [OP_JUMP_IF_FALSE] = &&DO_JUMP_IF_FALSE,
case OP_LOAD_NUMBER: [OP_JUMP] = &&DO_JUMP,
load_number(translated, state); [OP_NEW_SCOPE] = &&DO_NEW_SCOPE,
break; [OP_POP_SCOPE] = &&DO_POP_SCOPE,
case OP_LOAD_FUNCTION: [OP_INIT_CALL] = &&DO_INIT_CALL,
load_argon_function(translated, state, *stack); [OP_INSERT_ARG] = &&DO_INSERT_ARG,
break; [OP_CALL] = &&DO_CALL,
case OP_IDENTIFIER: [OP_SOURCE_LOCATION] = &&DO_SOURCE_LOCATION,
return load_variable(translated, state, *stack); [OP_LOAD_ACCESS_FUNCTION] = &&DO_LOAD_ACCESS_FUNCTION,
case OP_DECLARE: [OP_LOAD_BOOL] = &&DO_LOAD_BOOL,
return runtime_declaration(translated, state, *stack); [OP_LOAD_NUMBER] = &&DO_LOAD_NUMBER,
case OP_ASSIGN: [OP_LOAD_ADDITION_FUNCTION] = &&DO_LOAD_ADDITION_FUNCTION,
return runtime_assignment(translated, state, *stack); [OP_LOAD_SUBTRACTION_FUNCTION] = &&DO_LOAD_SUBTRACTION_FUNCTION,
case OP_BOOL:; [OP_LOAD_MULTIPLY_FUNCTION] = &&DO_LOAD_MULTIPLY_FUNCTION,
ArErr err = no_err; [OP_LOAD_DIVISION_FUNCTION] = &&DO_LOAD_DIVISION_FUNCTION,
uint8_t to_register = pop_byte(translated, state); [OP_ASSIGN] = &&DO_ASSIGN};
ArgonObject *args[] = {ARGON_BOOL_TYPE, state->registers[0]}; goto *dispatch_table[pop_byte(translated, state)];
state->registers[to_register] = DO_LOAD_NULL:
ARGON_BOOL_TYPE___new__(2, args, &err, state); state->registers[pop_byte(translated, state)] = ARGON_NULL;
return err; goto BREAK;
case OP_JUMP_IF_FALSE:; DO_LOAD_STRING:
uint8_t from_register = pop_byte(translated, state); load_const(translated, state);
uint64_t to = pop_bytecode(translated, state); goto BREAK;
if (state->registers[from_register] == ARGON_FALSE) { DO_LOAD_NUMBER:
state->head = to; load_number(translated, state);
} goto BREAK;
break; DO_LOAD_FUNCTION:
case OP_JUMP: load_argon_function(translated, state, *stack);
state->head = pop_bytecode(translated, state); goto BREAK;
break; DO_IDENTIFIER:
case OP_NEW_SCOPE: return load_variable(translated, state, *stack);
*stack = create_scope(*stack); DO_DECLARE:
break; return runtime_declaration(translated, state, *stack);
case OP_POP_SCOPE:; DO_ASSIGN:
// struct node_GC *array = return runtime_assignment(translated, state, *stack);
// checked_malloc(sizeof(struct node_GC) * (*stack)->scope->count); DO_BOOL:;
// size_t j = 0; ArErr err = no_err;
// for (size_t i = 0; i < (*stack)->scope->size; i++) { uint8_t to_register = pop_byte(translated, state);
// struct node_GC *temp = (*stack)->scope->list[i]; ArgonObject *args[] = {ARGON_BOOL_TYPE, state->registers[0]};
// while (temp) { state->registers[to_register] = ARGON_BOOL_TYPE___new__(2, args, &err, state);
// array[j++] = *temp; return err;
// temp = temp->next; DO_JUMP_IF_FALSE:;
// } uint8_t from_register = pop_byte(translated, state);
// } uint64_t to = pop_bytecode(translated, state);
// qsort(array, (*stack)->scope->count, sizeof(struct node_GC), if (state->registers[from_register] == ARGON_FALSE) {
// compare_by_order); state->head = to;
// for (size_t i = 0; i < (*stack)->scope->count; i++) {
// struct node_GC temp = array[i];
// printf("%.*s = %.*s\n",
// (int)((ArgonObject *)temp.key)->value.as_str.length,
// ((ArgonObject *)temp.key)->value.as_str.data,
// (int)((ArgonObject *)temp.val)->value.as_str.length,
// ((ArgonObject *)temp.val)->value.as_str.data);
// }
// free(array);
*stack = (*stack)->prev;
break;
case OP_INIT_CALL:;
size_t length = pop_bytecode(translated, state);
call_instance call_instance = {state->call_instance, state->registers[0],
ar_alloc(length * sizeof(ArgonObject *)),
length};
state->call_instance = ar_alloc(sizeof(call_instance));
*state->call_instance = call_instance;
break;
case OP_INSERT_ARG:;
size_t index = pop_bytecode(translated, state);
(state->call_instance->args)[index] = state->registers[0];
break;
case OP_CALL:;
err = run_call(state->call_instance->to_call,
state->call_instance->args_length,
state->call_instance->args, state, false);
state->call_instance = (*state->call_instance).previous;
return err;
// ArgonObject *object = state->registers[from_register];
// char *field = "__class__";
// uint64_t hash = siphash64_bytes(field, strlen(field), siphash_key);
// ArgonObject *class = hashmap_lookup_GC(object->dict, hash);
// field = "__name__";
// hash = siphash64_bytes(field, strlen(field), siphash_key);
// ArgonObject *class_name = hashmap_lookup_GC(class->dict, hash);
// hash = siphash64_bytes(field, strlen(field), siphash_key);
// ArgonObject *object_name = hashmap_lookup_GC(object->dict, hash);
// if (object_name) {
// printf("call <%.*s %.*s at %p>\n",
// (int)class_name->value.as_str.length,
// class_name->value.as_str.data,(int)object_name->value.as_str.length,
// object_name->value.as_str.data, object);
// } else {
// printf("call <%.*s object at %p>\n",
// (int)class_name->value.as_str.length, class_name->value.as_str.data,
// object);
// }
case OP_SOURCE_LOCATION:
state->source_location = (SourceLocation){pop_bytecode(translated, state),
pop_bytecode(translated, state),
pop_bytecode(translated, state)};
break;
case OP_LOAD_BOOL:
state->registers[0] =
pop_byte(translated, state) ? ARGON_TRUE : ARGON_FALSE;
break;
case OP_LOAD_ACCESS_FUNCTION:
state->registers[0] = ACCESS_FUNCTION;
break;
case OP_LOAD_ADDITION_FUNCTION:
state->registers[0] = ADDITION_FUNCTION;
break;
case OP_LOAD_SUBTRACTION_FUNCTION:
state->registers[0] = SUBTRACTION_FUNCTION;
break;
case OP_LOAD_MULTIPLY_FUNCTION:
state->registers[0] = MULTIPLY_FUNCTION;
break;
case OP_LOAD_DIVISION_FUNCTION:
state->registers[0] = DIVISION_FUNCTION;
break;
default:
return create_err(0, 0, 0, NULL, "Runtime Error", "Invalid Opcode %#x",
opcode);
} }
goto BREAK;
DO_JUMP:
state->head = pop_bytecode(translated, state);
goto BREAK;
DO_NEW_SCOPE:
*stack = create_scope(*stack);
goto BREAK;
DO_POP_SCOPE:;
// struct node_GC *array =
// checked_malloc(sizeof(struct node_GC) * (*stack)->scope->count);
// size_t j = 0;
// for (size_t i = 0; i < (*stack)->scope->size; i++) {
// struct node_GC *temp = (*stack)->scope->list[i];
// while (temp) {
// array[j++] = *temp;
// temp = temp->next;
// }
// }
// qsort(array, (*stack)->scope->count, sizeof(struct node_GC),
// compare_by_order);
// for (size_t i = 0; i < (*stack)->scope->count; i++) {
// struct node_GC temp = array[i];
// printf("%.*s = %.*s\n",
// (int)((ArgonObject *)temp.key)->value.as_str.length,
// ((ArgonObject *)temp.key)->value.as_str.data,
// (int)((ArgonObject *)temp.val)->value.as_str.length,
// ((ArgonObject *)temp.val)->value.as_str.data);
// }
// free(array);
*stack = (*stack)->prev;
goto BREAK;
DO_INIT_CALL:;
size_t length = pop_bytecode(translated, state);
call_instance call_instance = {state->call_instance, state->registers[0],
ar_alloc(length * sizeof(ArgonObject *)),
length};
state->call_instance = ar_alloc(sizeof(call_instance));
*state->call_instance = call_instance;
goto BREAK;
DO_INSERT_ARG:;
size_t index = pop_bytecode(translated, state);
(state->call_instance->args)[index] = state->registers[0];
goto BREAK;
DO_CALL:;
err =
run_call(state->call_instance->to_call, state->call_instance->args_length,
state->call_instance->args, state, false);
state->call_instance = (*state->call_instance).previous;
return err;
// ArgonObject *object = state->registers[from_register];
// char *field = "__class__";
// uint64_t hash = siphash64_bytes(field, strlen(field), siphash_key);
// ArgonObject *class = hashmap_lookup_GC(object->dict, hash);
// field = "__name__";
// hash = siphash64_bytes(field, strlen(field), siphash_key);
// ArgonObject *class_name = hashmap_lookup_GC(class->dict, hash);
// hash = siphash64_bytes(field, strlen(field), siphash_key);
// ArgonObject *object_name = hashmap_lookup_GC(object->dict, hash);
// if (object_name) {
// printf("call <%.*s %.*s at %p>\n",
// (int)class_name->value.as_str.length,
// class_name->value.as_str.data,(int)object_name->value.as_str.length,
// object_name->value.as_str.data, object);
// } else {
// printf("call <%.*s object at %p>\n",
// (int)class_name->value.as_str.length, class_name->value.as_str.data,
// object);
// }
DO_SOURCE_LOCATION:
state->source_location = (SourceLocation){pop_bytecode(translated, state),
pop_bytecode(translated, state),
pop_bytecode(translated, state)};
goto BREAK;
DO_LOAD_BOOL:
state->registers[0] = pop_byte(translated, state) ? ARGON_TRUE : ARGON_FALSE;
goto BREAK;
DO_LOAD_ACCESS_FUNCTION:
state->registers[0] = ACCESS_FUNCTION;
goto BREAK;
DO_LOAD_ADDITION_FUNCTION:
state->registers[0] = ADDITION_FUNCTION;
goto BREAK;
DO_LOAD_SUBTRACTION_FUNCTION:
state->registers[0] = SUBTRACTION_FUNCTION;
goto BREAK;
DO_LOAD_MULTIPLY_FUNCTION:
state->registers[0] = MULTIPLY_FUNCTION;
goto BREAK;
DO_LOAD_DIVISION_FUNCTION:
state->registers[0] = DIVISION_FUNCTION;
goto BREAK;
BREAK:
return no_err; return no_err;
} }

15
src/runtime/runtime.h
View File

@@ -64,11 +64,20 @@ uint64_t runtime_hash(const void *data, size_t len, uint64_t prehash);
void bootstrap_globals(); void bootstrap_globals();
uint8_t pop_byte(Translated *translated, RuntimeState *state); static inline uint8_t pop_byte(Translated *translated, RuntimeState *state) {
return *((uint8_t *)darray_get(&translated->bytecode, state->head++));
}
uint64_t pop_bytecode(Translated *translated, RuntimeState *state); static inline uint64_t pop_bytecode(Translated *translated,
RuntimeState *state) {
uint64_t value = 0;
for (int i = 0; i < 8; i++) {
value |= ((uint64_t)pop_byte(translated, state)) << (i * 8);
}
return value;
}
ArErr run_instruction(Translated *translated, RuntimeState *state, static inline ArErr run_instruction(Translated *translated, RuntimeState *state,
struct Stack **stack); struct Stack **stack);
RuntimeState init_runtime_state(Translated translated, char *path); RuntimeState init_runtime_state(Translated translated, char *path);