steve
/
factor
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

VM: Refactor dispatch to Factor style

db4
Erik Charlebois 2013-05-11 21:57:45 -04:00
parent 6955dd8565
commit d5f66d9561
2 changed files with 113 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
vm/dispatch.cpp
View File

@ -1,16 +1,13 @@
#include "master.hpp" #include "master.hpp"
namespace factor namespace factor {
{
cell factor_vm::search_lookup_alist(cell table, cell klass) cell factor_vm::search_lookup_alist(cell table, cell klass) {
{ array* elements = untag<array>(table);
array *elements = untag<array>(table);
fixnum index = array_capacity(elements) - 2; fixnum index = array_capacity(elements) - 2;
while(index >= 0) while (index >= 0) {
{ if (array_nth(elements, index) == klass)
if(array_nth(elements,index) == klass) return array_nth(elements, index + 1);
return array_nth(elements,index + 1);
else else
index -= 2; index -= 2;
} }
@ -18,141 +15,126 @@ cell factor_vm::search_lookup_alist(cell table, cell klass)
return false_object; return false_object;
} }
cell factor_vm::search_lookup_hash(cell table, cell klass, cell hashcode) cell factor_vm::search_lookup_hash(cell table, cell klass, cell hashcode) {
{ array* buckets = untag<array>(table);
array *buckets = untag<array>(table); cell bucket = array_nth(buckets, hashcode & (array_capacity(buckets) - 1));
cell bucket = array_nth(buckets,hashcode & (array_capacity(buckets) - 1)); if (TAG(bucket) == ARRAY_TYPE)
if(TAG(bucket) == ARRAY_TYPE) return search_lookup_alist(bucket, klass);
return search_lookup_alist(bucket,klass);
else else
return bucket; return bucket;
} }
cell factor_vm::nth_superclass(tuple_layout *layout, fixnum echelon) cell factor_vm::nth_superclass(tuple_layout* layout, fixnum echelon) {
{ cell* ptr = (cell*)(layout + 1);
cell *ptr = (cell *)(layout + 1);
return ptr[echelon * 2]; return ptr[echelon * 2];
} }
cell factor_vm::nth_hashcode(tuple_layout *layout, fixnum echelon) cell factor_vm::nth_hashcode(tuple_layout* layout, fixnum echelon) {
{ cell* ptr = (cell*)(layout + 1);
cell *ptr = (cell *)(layout + 1);
return ptr[echelon * 2 + 1]; return ptr[echelon * 2 + 1];
} }
cell factor_vm::lookup_tuple_method(cell obj, cell methods) cell factor_vm::lookup_tuple_method(cell obj, cell methods) {
{ tuple_layout* layout = untag<tuple_layout>(untag<tuple>(obj)->layout);
tuple_layout *layout = untag<tuple_layout>(untag<tuple>(obj)->layout);
array *echelons = untag<array>(methods); array* echelons = untag<array>(methods);
fixnum echelon = std::min(untag_fixnum(layout->echelon),(fixnum)array_capacity(echelons) - 1); fixnum echelon = std::min(untag_fixnum(layout->echelon),
(fixnum) array_capacity(echelons) - 1);
while(echelon >= 0) while (echelon >= 0) {
{ cell echelon_methods = array_nth(echelons, echelon);
cell echelon_methods = array_nth(echelons,echelon);
if(tagged<object>(echelon_methods).type_p(WORD_TYPE)) if (tagged<object>(echelon_methods).type_p(WORD_TYPE))
return echelon_methods; return echelon_methods;
else if(to_boolean(echelon_methods)) else if (to_boolean(echelon_methods)) {
{ cell klass = nth_superclass(layout, echelon);
cell klass = nth_superclass(layout,echelon); cell hashcode = untag_fixnum(nth_hashcode(layout, echelon));
cell hashcode = untag_fixnum(nth_hashcode(layout,echelon)); cell result = search_lookup_hash(echelon_methods, klass, hashcode);
cell result = search_lookup_hash(echelon_methods,klass,hashcode); if (to_boolean(result))
if(to_boolean(result))
return result; return result;
} }
echelon--; echelon--;
} }
critical_error("Cannot find tuple method",methods); critical_error("Cannot find tuple method", methods);
return false_object; return false_object;
} }
cell factor_vm::lookup_method(cell obj, cell methods) cell factor_vm::lookup_method(cell obj, cell methods) {
{
cell tag = TAG(obj); cell tag = TAG(obj);
cell method = array_nth(untag<array>(methods),tag); cell method = array_nth(untag<array>(methods), tag);
if(tag == TUPLE_TYPE) if (tag == TUPLE_TYPE) {
{ if (TAG(method) == ARRAY_TYPE)
if(TAG(method) == ARRAY_TYPE) return lookup_tuple_method(obj, method);
return lookup_tuple_method(obj,method);
else else
return method; return method;
} } else
else
return method; return method;
} }
void factor_vm::primitive_lookup_method() void factor_vm::primitive_lookup_method() {
{
cell methods = ctx->pop(); cell methods = ctx->pop();
cell obj = ctx->pop(); cell obj = ctx->pop();
ctx->push(lookup_method(obj,methods)); ctx->push(lookup_method(obj, methods));
} }
cell factor_vm::object_class(cell obj) cell factor_vm::object_class(cell obj) {
{
cell tag = TAG(obj); cell tag = TAG(obj);
if(tag == TUPLE_TYPE) if (tag == TUPLE_TYPE)
return untag<tuple>(obj)->layout; return untag<tuple>(obj)->layout;
else else
return tag_fixnum(tag); return tag_fixnum(tag);
} }
cell factor_vm::method_cache_hashcode(cell klass, array *array) cell factor_vm::method_cache_hashcode(cell klass, array* array) {
{
cell capacity = (array_capacity(array) >> 1) - 1; cell capacity = (array_capacity(array) >> 1) - 1;
return ((klass >> TAG_BITS) & capacity) << 1; return ((klass >> TAG_BITS) & capacity) << 1;
} }
void factor_vm::update_method_cache(cell cache, cell klass, cell method) void factor_vm::update_method_cache(cell cache, cell klass, cell method) {
{ array* cache_elements = untag<array>(cache);
array *cache_elements = untag<array>(cache); cell hashcode = method_cache_hashcode(klass, cache_elements);
cell hashcode = method_cache_hashcode(klass,cache_elements); set_array_nth(cache_elements, hashcode, klass);
set_array_nth(cache_elements,hashcode,klass); set_array_nth(cache_elements, hashcode + 1, method);
set_array_nth(cache_elements,hashcode + 1,method);
} }
void factor_vm::primitive_mega_cache_miss() void factor_vm::primitive_mega_cache_miss() {
{
dispatch_stats.megamorphic_cache_misses++; dispatch_stats.megamorphic_cache_misses++;
cell cache = ctx->pop(); cell cache = ctx->pop();
fixnum index = untag_fixnum(ctx->pop()); fixnum index = untag_fixnum(ctx->pop());
cell methods = ctx->pop(); cell methods = ctx->pop();
cell object = ((cell *)ctx->datastack)[-index]; cell object = ((cell*)ctx->datastack)[-index];
cell klass = object_class(object); cell klass = object_class(object);
cell method = lookup_method(object,methods); cell method = lookup_method(object, methods);
update_method_cache(cache,klass,method); update_method_cache(cache, klass, method);
ctx->push(method); ctx->push(method);
} }
void factor_vm::primitive_reset_dispatch_stats() void factor_vm::primitive_reset_dispatch_stats() {
{ memset(&dispatch_stats, 0, sizeof(dispatch_statistics));
memset(&dispatch_stats,0,sizeof(dispatch_statistics));
} }
/* Allocates memory */ /* Allocates memory */
void factor_vm::primitive_dispatch_stats() void factor_vm::primitive_dispatch_stats() {
{
ctx->push(tag<byte_array>(byte_array_from_value(&dispatch_stats))); ctx->push(tag<byte_array>(byte_array_from_value(&dispatch_stats)));
} }
void quotation_jit::emit_mega_cache_lookup(cell methods_, fixnum index, cell cache_) void quotation_jit::emit_mega_cache_lookup(cell methods_, fixnum index,
{ cell cache_) {
data_root<array> methods(methods_,parent); data_root<array> methods(methods_, parent);
data_root<array> cache(cache_,parent); data_root<array> cache(cache_, parent);
/* The object must be on the top of the datastack at this point. */ /* The object must be on the top of the datastack at this point. */
/* Do a cache lookup. */ /* Do a cache lookup. */
emit_with_literal(parent->special_objects[MEGA_LOOKUP],cache.value()); emit_with_literal(parent->special_objects[MEGA_LOOKUP], cache.value());
/* If we end up here, the cache missed. */ /* If we end up here, the cache missed. */
emit(parent->special_objects[JIT_PROLOG]); emit(parent->special_objects[JIT_PROLOG]);

3
vm/dispatch.hpp
View File

@ -1,5 +1,4 @@
namespace factor namespace factor {
{
struct dispatch_statistics { struct dispatch_statistics {
cell megamorphic_cache_hits; cell megamorphic_cache_hits;