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

improve performance massively from 0.9 seconds to 0.38 seconds :)

Browse Source
This commit is contained in:
William Bell
2025-09-01 20:25:47 +01:00
parent 4f91bf48f3
commit 19268f3070
24 changed files with 479 additions and 369 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
src/runtime/objects/functions/functions.c
View File

@@ -7,38 +7,43 @@
#include "../../runtime.h"
#include "../object.h"
#include "../string/string.h"
#include <stdio.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
ArgonObject *ARGON_FUNCTION_TYPE = NULL;
ArgonObject *create_argon_native_function(char*name, native_fn native_fn) {
ArgonObject *create_argon_native_function(char *name, native_fn native_fn) {
ArgonObject *object = new_object();
add_field(object, "__class__", ARGON_FUNCTION_TYPE);
add_builtin_field(object, __class__, ARGON_FUNCTION_TYPE);
object->type = TYPE_NATIVE_FUNCTION;
add_field(object, "__name__", new_string_object(name, strlen(name)));
add_builtin_field(object, __name__,
new_string_object(name, strlen(name), 0, 0));
object->value.native_fn = native_fn;
return object;
}
void load_argon_function(Translated *translated, RuntimeState *state,
struct Stack *stack) {
struct Stack *stack) {
ArgonObject *object = new_object();
add_field(object, "__class__", ARGON_FUNCTION_TYPE);
add_builtin_field(object, __class__, ARGON_FUNCTION_TYPE);
object->type = TYPE_FUNCTION;
uint64_t offset = pop_bytecode(translated, state);
uint64_t length = pop_bytecode(translated, state);
add_field(object, "__name__", new_string_object(arena_get(&translated->constants, offset), length));
add_builtin_field(object, __name__,
new_string_object(arena_get(&translated->constants, offset),
length, 0, 0));
object->value.argon_fn.translated = *translated;
object->value.argon_fn.number_of_parameters = pop_bytecode(translated, state);
object->value.argon_fn.parameters =
ar_alloc(object->value.argon_fn.number_of_parameters * sizeof(struct string_struct));
ar_alloc(object->value.argon_fn.number_of_parameters *
sizeof(struct string_struct));
for (size_t i = 0; i < object->value.argon_fn.number_of_parameters; i++) {
offset = pop_bytecode(translated, state);
length = pop_bytecode(translated, state);
object->value.argon_fn.parameters[i].data = arena_get(&translated->constants, offset);
object->value.argon_fn.parameters[i].data =
arena_get(&translated->constants, offset);
object->value.argon_fn.parameters[i].length = length;
}
offset = pop_bytecode(translated, state);
@@ -46,5 +51,5 @@ void load_argon_function(Translated *translated, RuntimeState *state,
object->value.argon_fn.bytecode = arena_get(&translated->constants, offset);
object->value.argon_fn.bytecode_length = length;
object->value.argon_fn.stack = stack;
state->registers[0]=object;
state->registers[0] = object;
}

56
src/runtime/objects/number/number.c
View File

@@ -37,8 +37,8 @@ ArgonObject *ARGON_NUMBER_TYPE___new__(size_t argc, ArgonObject **argv,
ArgonObject *object = argv[1];
self->type = TYPE_STRING;
ArgonObject *boolean_convert_method = get_field_for_class(
get_field(object, "__class__", false, false), "__number__", object);
ArgonObject *boolean_convert_method = get_builtin_field_for_class(
get_builtin_field(object, __class__, false, false), __number__, object);
if (boolean_convert_method) {
ArgonObject *boolean_object =
argon_call(boolean_convert_method, 0, NULL, err, state);
@@ -46,8 +46,8 @@ ArgonObject *ARGON_NUMBER_TYPE___new__(size_t argc, ArgonObject **argv,
return ARGON_NULL;
return boolean_object;
}
ArgonObject *type_name = get_field_for_class(
get_field(object, "__class__", false, false), "__name__", object);
ArgonObject *type_name = get_builtin_field_for_class(
get_builtin_field(object, __class__, false, false), __name__, object);
*err = create_err(
0, 0, 0, "", "Runtime Error", "cannot convert type '%.*s' to number",
type_name->value.as_str.length, type_name->value.as_str.data);
@@ -85,8 +85,8 @@ ArgonObject *ARGON_NUMBER_TYPE___add__(size_t argc, ArgonObject **argv,
return ARGON_NULL;
}
if (argv[1]->type != TYPE_NUMBER) {
ArgonObject *type_name = get_field_for_class(
get_field(argv[1], "__class__", false, false), "__name__", argv[1]);
ArgonObject *type_name = get_builtin_field_for_class(
get_builtin_field(argv[1], __class__, false, false), __name__, argv[1]);
*err = create_err(
0, 0, 0, "", "Runtime Error",
"__add__ cannot perform addition between a number and %.*s",
@@ -150,8 +150,8 @@ ArgonObject *ARGON_NUMBER_TYPE___subtract__(size_t argc, ArgonObject **argv,
mpq_t r;
mpq_init(r);
if (argv[1]->type != TYPE_NUMBER) {
ArgonObject *type_name = get_field_for_class(
get_field(argv[1], "__class__", false, false), "__name__", argv[1]);
ArgonObject *type_name = get_builtin_field_for_class(
get_builtin_field(argv[1], __class__, false, false), __name__, argv[1]);
*err = create_err(
0, 0, 0, "", "Runtime Error",
"__subtract__ cannot perform subtraction between number and %.*s",
@@ -216,8 +216,8 @@ ArgonObject *ARGON_NUMBER_TYPE___multiply__(size_t argc, ArgonObject **argv,
mpq_t r;
mpq_init(r);
if (argv[1]->type != TYPE_NUMBER) {
ArgonObject *type_name = get_field_for_class(
get_field(argv[1], "__class__", false, false), "__name__", argv[1]);
ArgonObject *type_name = get_builtin_field_for_class(
get_builtin_field(argv[1], __class__, false, false), __name__, argv[1]);
*err = create_err(
0, 0, 0, "", "Runtime Error",
"__multiply__ cannot perform multiplication between number and %.*s",
@@ -241,8 +241,8 @@ ArgonObject *ARGON_NUMBER_TYPE___division__(size_t argc, ArgonObject **argv,
mpq_t r;
mpq_init(r);
if (argv[1]->type != TYPE_NUMBER) {
ArgonObject *type_name = get_field_for_class(
get_field(argv[1], "__class__", false, false), "__name__", argv[1]);
ArgonObject *type_name = get_builtin_field_for_class(
get_builtin_field(argv[1], __class__, false, false), __name__, argv[1]);
*err = create_err(
0, 0, 0, "", "Runtime Error",
"__division__ cannot perform division between number and %.*s",
@@ -418,8 +418,8 @@ void init_small_ints() {
for (uint64_t i = 0; i < UINT8_MAX * 2; i++) {
small_ints[i].type = TYPE_NUMBER;
small_ints[i].dict = createHashmap_GC();
add_field(&small_ints[i], "__class__", ARGON_NUMBER_TYPE);
add_field(&small_ints[i], "__base__", BASE_CLASS);
add_builtin_field(&small_ints[i], __class__, ARGON_NUMBER_TYPE);
add_builtin_field(&small_ints[i], __base__, BASE_CLASS);
small_ints[i].value.as_number.is_int64 = true;
small_ints[i].value.as_number.n.i64 = i;
small_ints[i].as_bool = i;
@@ -428,28 +428,28 @@ void init_small_ints() {
void create_ARGON_NUMBER_TYPE() {
ARGON_NUMBER_TYPE = new_object();
add_field(ARGON_NUMBER_TYPE, "__name__",
add_builtin_field(ARGON_NUMBER_TYPE, __name__,
new_string_object_null_terminated("number"));
add_field(
ARGON_NUMBER_TYPE, "__string__",
add_builtin_field(
ARGON_NUMBER_TYPE, __string__,
create_argon_native_function("__string__", ARGON_NUMBER_TYPE___string__));
add_field(ARGON_NUMBER_TYPE, "__new__",
add_builtin_field(ARGON_NUMBER_TYPE, __new__,
create_argon_native_function("__new__", ARGON_NUMBER_TYPE___new__));
add_field(
ARGON_NUMBER_TYPE, "__number__",
add_builtin_field(
ARGON_NUMBER_TYPE, __number__,
create_argon_native_function("__number__", ARGON_NUMBER_TYPE___number__));
add_field(ARGON_NUMBER_TYPE, "__boolean__",
add_builtin_field(ARGON_NUMBER_TYPE, __boolean__,
create_argon_native_function("__boolean__",
ARGON_NUMBER_TYPE___boolean__));
add_field(ARGON_NUMBER_TYPE, "__add__",
add_builtin_field(ARGON_NUMBER_TYPE, __add__,
create_argon_native_function("__add__", ARGON_NUMBER_TYPE___add__));
add_field(ARGON_NUMBER_TYPE, "__subtract__",
add_builtin_field(ARGON_NUMBER_TYPE, __subtract__,
create_argon_native_function("__subtract__",
ARGON_NUMBER_TYPE___subtract__));
add_field(ARGON_NUMBER_TYPE, "__multiply__",
add_builtin_field(ARGON_NUMBER_TYPE, __multiply__,
create_argon_native_function("__multiply__",
ARGON_NUMBER_TYPE___multiply__));
add_field(ARGON_NUMBER_TYPE, "__division__",
add_builtin_field(ARGON_NUMBER_TYPE, __division__,
create_argon_native_function("__division__",
ARGON_NUMBER_TYPE___division__));
init_small_ints();
@@ -534,7 +534,7 @@ ArgonObject *new_number_object(mpq_t number) {
return &small_ints[i64];
}
ArgonObject *object = new_object();
add_field(object, "__class__", ARGON_NUMBER_TYPE);
add_builtin_field(object, __class__, ARGON_NUMBER_TYPE);
object->type = TYPE_NUMBER;
object->value.as_number.n.i64 = i64;
object->value.as_number.is_int64 = is_int64;
@@ -552,7 +552,7 @@ ArgonObject *new_number_object_from_num_and_den(int64_t n, uint64_t d) {
return &small_ints[(int8_t)n];
}
ArgonObject *object = new_object();
add_field(object, "__class__", ARGON_NUMBER_TYPE);
add_builtin_field(object, __class__, ARGON_NUMBER_TYPE);
object->type = TYPE_NUMBER;
if (d == 1) {
object->value.as_number.is_int64 = true;
@@ -577,7 +577,7 @@ ArgonObject *new_number_object_from_double(double d) {
return &small_ints[(int8_t)i64];
}
ArgonObject *object = new_object();
add_field(object, "__class__", ARGON_NUMBER_TYPE);
add_builtin_field(object, __class__, ARGON_NUMBER_TYPE);
object->type = TYPE_NUMBER;
object->value.as_number.n.i64 = i64;
object->value.as_number.is_int64 = is_int64;

104
src/runtime/objects/object.c
View File

@@ -15,42 +15,62 @@
ArgonObject *BASE_CLASS = NULL;
const char *built_in_field_names[BUILT_IN_FIELDS_COUNT] = {
"__base__", "__class__", "__name__", "__add__",
"__string__", "__subtract__", "__multiply__", "__division__",
"__new__", "__init__", "__boolean__", "__get_attr__",
"__binding__", "__function__", "address", "__call__",
"__number__", "log"};
uint64_t built_in_field_hashes[BUILT_IN_FIELDS_COUNT];
ArgonObject *new_object() {
ArgonObject *object = ar_alloc(sizeof(ArgonObject));
object->type = TYPE_OBJECT;
object->dict = createHashmap_GC();
add_field(object, "__class__", ARGON_TYPE_TYPE);
add_field(object, "__base__", BASE_CLASS);
add_builtin_field(object, __class__, ARGON_TYPE_TYPE);
add_builtin_field(object, __base__, BASE_CLASS);
object->as_bool = true;
return object;
}
void add_field(ArgonObject *target, char *name, ArgonObject *object) {
hashmap_insert_GC(target->dict,
siphash64_bytes(name, strlen(name), siphash_key), name,
object, 0);
void init_built_in_field_hashes() {
for (int i = 0; i < BUILT_IN_FIELDS_COUNT; i++) {
built_in_field_hashes[i] = siphash64_bytes(
built_in_field_names[i], strlen(built_in_field_names[i]), siphash_key);
}
}
void add_builtin_field(ArgonObject *target, built_in_fields field,
ArgonObject *object) {
hashmap_insert_GC(target->dict, built_in_field_hashes[field],
(char *)built_in_field_names[field], object, 0);
}
void add_field(ArgonObject *target, char *name, uint64_t hash,
ArgonObject *object) {
hashmap_insert_GC(target->dict, hash, name, object, 0);
}
ArgonObject *bind_object_to_function(ArgonObject *object,
ArgonObject *function) {
ArgonObject *bound_method_wrapper = new_object();
bound_method_wrapper->type = TYPE_METHOD;
add_field(bound_method_wrapper, "__class__", ARGON_METHOD_TYPE);
add_field(bound_method_wrapper, "__binding__", object);
add_field(bound_method_wrapper, "__function__", function);
ArgonObject *function_name = get_field(function, "__name__", false, false);
add_builtin_field(bound_method_wrapper, __class__, ARGON_METHOD_TYPE);
add_builtin_field(bound_method_wrapper, __binding__, object);
add_builtin_field(bound_method_wrapper, __function__, function);
ArgonObject *function_name =
get_builtin_field(function, __name__, false, false);
if (function_name)
add_field(bound_method_wrapper, "__name__", function_name);
add_builtin_field(bound_method_wrapper, __name__, function_name);
return bound_method_wrapper;
}
ArgonObject *get_field_for_class_l(ArgonObject *target, char *name,
size_t length, ArgonObject *binding_object) {
char *field = "__base__";
size_t field_size = strlen(field);
uint64_t hash, size_t length,
ArgonObject *binding_object) {
while (target) {
ArgonObject *object = get_field_l(target, name, length, false, false);
ArgonObject *object = get_field_l(target, name, hash, length, false, false);
if (object) {
if ((object->type == TYPE_FUNCTION ||
object->type == TYPE_NATIVE_FUNCTION) &&
@@ -59,35 +79,53 @@ ArgonObject *get_field_for_class_l(ArgonObject *target, char *name,
}
return object;
}
target = get_field_l(target, field, field_size, false, false);
target = get_builtin_field(target, __base__, false, false);
}
return NULL;
}
ArgonObject *get_field_l(ArgonObject *target, char *name, size_t length,
bool recursive, bool disable_method_wrapper) {
if(!target|| !target->dict) return NULL;
char *field = "__class__";
size_t field_size = strlen(field);
ArgonObject *object = hashmap_lookup_GC(
target->dict, siphash64_bytes(name, length, siphash_key));
ArgonObject *get_field_l(ArgonObject *target, char *name, uint64_t hash,
size_t length, bool recursive,
bool disable_method_wrapper) {
ArgonObject *object = hashmap_lookup_GC(target->dict, hash);
if (!recursive || object)
return object;
ArgonObject *binding = target;
if (disable_method_wrapper)
binding = NULL;
return get_field_for_class_l(
hashmap_lookup_GC(target->dict,
siphash64_bytes(field, field_size, siphash_key)),
name, length, binding);
hashmap_lookup_GC(target->dict, built_in_field_hashes[__class__]), name,
hash, length, binding);
}
ArgonObject *get_field(ArgonObject *target, char *name, bool recursive,
bool disable_method_wrapper) {
return get_field_l(target, name, strlen(name), recursive,
disable_method_wrapper);
ArgonObject *get_builtin_field_for_class(ArgonObject *target,
built_in_fields field,
ArgonObject *binding_object) {
while (target) {
ArgonObject *object = get_builtin_field(target, field, false, false);
if (object) {
if ((object->type == TYPE_FUNCTION ||
object->type == TYPE_NATIVE_FUNCTION) &&
binding_object) {
object = bind_object_to_function(binding_object, object);
}
return object;
}
target = get_builtin_field(target, __base__, false, false);
}
return NULL;
}
ArgonObject *get_field_for_class(ArgonObject *target, char *name,
ArgonObject *binding_object) {
return get_field_for_class_l(target, name, strlen(name), binding_object);
ArgonObject *get_builtin_field(ArgonObject *target, built_in_fields field,
bool recursive, bool disable_method_wrapper) {
ArgonObject *object =
hashmap_lookup_GC(target->dict, built_in_field_hashes[field]);
if (!recursive || object)
return object;
ArgonObject *binding = target;
if (disable_method_wrapper)
binding = NULL;
return get_builtin_field_for_class(
hashmap_lookup_GC(target->dict, built_in_field_hashes[__class__]), field,
binding);
}

48
src/runtime/objects/object.h
View File

@@ -9,27 +9,59 @@
#include "../internals/hashmap/hashmap.h"
#include "../runtime.h"
#include <stdbool.h>
#include <string.h>
typedef enum {
__base__,
__class__,
__name__,
__add__,
__string__,
__subtract__,
__multiply__,
__division__,
__new__,
__init__,
__boolean__,
__get_attr__,
__binding__,
__function__,
field__address,
__call__,
__number__,
field_log,
BUILT_IN_FIELDS_COUNT
} built_in_fields;
void init_built_in_field_hashes();
extern ArgonObject *BASE_CLASS;
typedef struct ArgonObject ArgonObject;
ArgonObject *new_object();
void add_field(ArgonObject *target, char *name, ArgonObject *object);
void add_builtin_field(ArgonObject *target, built_in_fields field,
ArgonObject *object);
void add_field(ArgonObject *target, char *name, uint64_t hash,
ArgonObject *object);
ArgonObject *bind_object_to_function(ArgonObject *object,
ArgonObject *function);
ArgonObject *get_field_for_class_l(ArgonObject *target, char *name,
size_t length, ArgonObject *binding_object);
uint64_t hash, size_t length,
ArgonObject *binding_object);
ArgonObject *get_field_l(ArgonObject *target, char *name, size_t length,
bool recursive, bool disable_method_wrapper);
ArgonObject *get_field_l(ArgonObject *target, char *name, uint64_t hash,
size_t length, bool recursive,
bool disable_method_wrapper);
ArgonObject *get_field_for_class(ArgonObject *target, char *name,
ArgonObject *binding_object);
ArgonObject *get_builtin_field_for_class(ArgonObject *target,
built_in_fields field,
ArgonObject *binding_object);
ArgonObject *get_field(ArgonObject *target, char *name, bool recursive,
bool disable_method_wrapper);
ArgonObject *get_builtin_field(ArgonObject *target, built_in_fields field,
bool recursive, bool disable_method_wrapper);
#endif // OBJECT_H

22
src/runtime/objects/string/string.c
View File

@@ -4,28 +4,32 @@
* SPDX-License-Identifier: GPL-3.0-or-later
*/
#include "string.h"
#include "../number/number.h"
#include "../object.h"
#include <stdint.h>
#include <stdio.h>
#include <stdio.h>
#include <string.h>
#include "string.h"
#include "../number/number.h"
ArgonObject *ARGON_STRING_TYPE = NULL;
ArgonObject *new_string_object(char*data, size_t length) {
ArgonObject * object = new_object();
add_field(object, "__class__", ARGON_STRING_TYPE);
add_field(object, "length", new_number_object_from_num_and_den(length, 1));
ArgonObject *new_string_object(char *data, size_t length, uint64_t prehash,
uint64_t hash) {
ArgonObject *object = new_object();
add_builtin_field(object, __class__, ARGON_STRING_TYPE);
add_builtin_field(object, length,
new_number_object_from_num_and_den(length, 1));
object->type = TYPE_STRING;
object->value.as_str.data = ar_alloc_atomic(length);
memcpy(object->value.as_str.data, data, length);
object->value.as_str.prehash = prehash;
object->value.as_str.hash_computed = hash;
object->value.as_str.hash = hash;
object->value.as_str.length = length;
object->as_bool = length;
return object;
}
ArgonObject *new_string_object_null_terminated(char*data) {
return new_string_object(data, strlen(data));
ArgonObject *new_string_object_null_terminated(char *data) {
return new_string_object(data, strlen(data), 0, 0);
}

2
src/runtime/objects/string/string.h
View File

@@ -10,7 +10,7 @@
extern ArgonObject *ARGON_STRING_TYPE;
ArgonObject *new_string_object(char*data, size_t length);
ArgonObject *new_string_object(char *data, size_t length, uint64_t prehash, uint64_t hash);
ArgonObject *new_string_object_null_terminated(char*data);
#endif // STRING_OBJ_H

4
src/runtime/objects/term/term.c
View File

@@ -13,8 +13,8 @@ ArgonObject *term_log(size_t argc, ArgonObject **argv, ArErr *err,
for (size_t i = 0; i < argc; i++) {
if (i != 0)
printf(" ");
ArgonObject *string_convert_method = get_field_for_class(
get_field(argv[i], "__class__", false, false), "__string__", argv[i]);
ArgonObject *string_convert_method = get_builtin_field_for_class(
get_builtin_field(argv[i], __class__, false, false), __string__, argv[i]);
if (string_convert_method) {
ArgonObject *string_object =