From e2f4c189f998621c396eb2e9d5cd56f43d05c9ae Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 9 Mar 2020 18:11:36 +0900 Subject: [PATCH] [ruamoko] Install and use dispatch tables This should speed up ruamoko code somewhat as hash table lookups have been replaced with direct array indexing. As a bonus, support for message forwarding has been added (though not tested). --- include/QF/pr_obj.h | 2 +- libs/ruamoko/rua_obj.c | 125 ++++++++++++++++++++++++++++++++++++++++- 2 files changed, 124 insertions(+), 3 deletions(-) diff --git a/include/QF/pr_obj.h b/include/QF/pr_obj.h index fa3bbca84..52f05aa16 100644 --- a/include/QF/pr_obj.h +++ b/include/QF/pr_obj.h @@ -94,7 +94,7 @@ typedef struct pr_class_s { pr_int_t instance_size; pointer_t ivars; // pr_ivar_list_t pointer_t methods; // pr_method_list_t - pointer_t dtable; + pointer_t dtable; // resource index pointer_t subclass_list; // pr_class_t pointer_t sibling_class; // pr_class_t pointer_t protocols; // pr_protocol_list_t diff --git a/libs/ruamoko/rua_obj.c b/libs/ruamoko/rua_obj.c index a8c2f9e7b..50ba97de1 100644 --- a/libs/ruamoko/rua_obj.c +++ b/libs/ruamoko/rua_obj.c @@ -56,17 +56,26 @@ #include "compat.h" #include "rua_internal.h" +#define always_inline inline __attribute__((__always_inline__)) + typedef struct obj_list_s { struct obj_list_s *next; void *data; } obj_list; +typedef struct dtable_s { + size_t size; + func_t *imp; +} dtable_t; + typedef struct probj_resources_s { progs_t *pr; unsigned selector_index; unsigned selector_index_max; obj_list **selector_sels; string_t *selector_names; + PR_RESMAP (dtable_t) dtables; + func_t obj_forward; hashtab_t *selector_hash; hashtab_t *classes; hashtab_t *protocols; @@ -79,6 +88,41 @@ typedef struct probj_resources_s { obj_list *class_tree_list; } probj_t; +static dtable_t * +dtable_new (probj_t *probj) +{ + PR_RESNEW (dtable_t, probj->dtables); +} + +static void +dtable_reset (probj_t *probj) +{ + PR_RESRESET (dtable_t, probj->dtables); +} + +static inline dtable_t * +dtable_get (probj_t *probj, int index) +{ + PR_RESGET (probj->dtables, index); +} + +static inline int +dtable_index (probj_t *probj, dtable_t *dtable) +{ + PR_RESINDEX (probj->dtables, dtable); +} + +static always_inline dtable_t * __attribute__((pure)) +get_dtable (probj_t *probj, const char *name, int index) +{ + dtable_t *dtable = dtable_get (probj, index); + + if (!dtable) { + PR_RunError (probj->pr, "invalid dtable index in %s", name); + } + return dtable; +} + static obj_list *obj_list_free_list; static obj_list * @@ -832,12 +876,83 @@ obj_send_initialize (probj_t *probj, pr_class_t *class) } } +static void +obj_install_methods_in_dtable (probj_t *probj, pr_class_t *class, + pr_method_list_t *method_list) +{ + progs_t *pr = probj->pr; + dtable_t *dtable; + + if (!method_list) { + return; + } + if (method_list->method_next) { + obj_install_methods_in_dtable (probj, class, + &G_STRUCT (pr, pr_method_list_t, + method_list->method_next)); + } + + dtable = get_dtable (probj, __FUNCTION__, class->dtable); + for (int i = 0; i < method_list->method_count; i++) { + pr_method_t *method = &method_list->method_list[i]; + pr_sel_t *sel = &G_STRUCT (pr, pr_sel_t, method->method_name); + if (sel->sel_id < dtable->size) { + dtable->imp[sel->sel_id] = method->method_imp; + } + } +} + +static void +obj_install_dispatch_table_for_class (probj_t *probj, pr_class_t *class) +{ + progs_t *pr = probj->pr; + pr_class_t *super = &G_STRUCT (pr, pr_class_t, class->super_class); + dtable_t *dtable; + + Sys_MaskPrintf (SYS_RUA_OBJ, " install dispatch for class %s %x %d\n", + PR_GetString (pr, class->name), + class->methods, + PR_CLS_ISMETA(class)); + + if (super && !super->dtable) { + obj_install_dispatch_table_for_class (probj, super); + } + + dtable = dtable_new (probj); + class->dtable = dtable_index (probj, dtable); + dtable->size = probj->selector_index + 1; + dtable->imp = calloc (dtable->size, sizeof (func_t)); + if (super) { + dtable_t *super_dtable = get_dtable (probj, __FUNCTION__, + super->dtable); + memcpy (dtable->imp, super_dtable->imp, + super_dtable->size * sizeof (*dtable->imp)); + } + obj_install_methods_in_dtable (probj, class, + &G_STRUCT (pr, pr_method_list_t, + class->methods)); +} + static func_t get_imp (probj_t *probj, pr_class_t *class, pr_sel_t *sel) { - pr_method_t *method = obj_find_message (probj, class, sel); + func_t imp = 0; - return method ? method->method_imp : 0; + if (class->dtable) { + dtable_t *dtable = get_dtable (probj, __FUNCTION__, class->dtable); + if (sel->sel_id < dtable->size) { + imp = dtable->imp[sel->sel_id]; + } + } + if (!imp) { + if (!class->dtable) { + obj_install_dispatch_table_for_class (probj, class); + imp = get_imp (probj, class, sel); + } else { + imp = probj->obj_forward; + } + } + return imp; } static func_t @@ -1908,10 +2023,16 @@ rua_obj_init_runtime (progs_t *pr) { probj_t *probj = pr->pr_objective_resources; pr_def_t *def; + dfunction_t *obj_forward; if ((def = PR_FindField (pr, ".this"))) pr->fields.this = def->ofs; + probj->obj_forward = 0; + if ((obj_forward = PR_FindFunction (pr, "__obj_forward"))) { + probj->obj_forward = (intptr_t) (obj_forward - pr->pr_functions); + } + PR_AddLoadFinishFunc (pr, rua_init_finish); return 1; }