miloignis/kraken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replace visited list for pass_common with hash_set (which isn't complete, but has the basics) for a massive speedup (6xish)

Browse Source
This commit is contained in:
Nathan Braswell
2017-01-22 10:13:06 -05:00
parent 896e8a936c
commit ebb34d5ba3
8 changed files with 74 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
stdlib/adt_lower.krak
View File

@@ -8,13 +8,14 @@ import mem:*
import io:*
import ast_nodes:*
import ast_transformation:*
import hash_set:*
import pass_common:*
fun adt_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_syntax: *map<*ast_node, *tree<symbol>>) {
var type_def_option_map = map<*ast_node, vector<*ast_node>>()
var visited1 = set<*ast_node>()
var visited2 = set<*ast_node>()
var visited1 = hash_set<*ast_node>()
var visited2 = hash_set<*ast_node>()
name_ast_map->for_each(fun(name: string, syntax_ast_pair: pair<*tree<symbol>,*ast_node>) {
var helper_before = fun(node: *ast_node, parent_chain: *stack<*ast_node>) {
match(*node) {
@@ -53,7 +54,7 @@ fun adt_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
block->code_block.children.add(ast_assignment_statement_ptr(make_operator_call(".", vector(to_ret, flag)), value))
var opt = type_def_option_map[node][idx]
var lvalue = make_operator_call(".", vector(make_operator_call(".", vector(to_ret, option_union_ident)), opt))
if (func->function.parameters.size) {
if (func->function.parameters.size) {
// do copy_construct if it should
block->code_block.children.add(assign_or_copy_construct_statement(lvalue, func->function.parameters[0]))
}

3
stdlib/ctce_lower.krak
View File

@@ -9,11 +9,12 @@ import io:*
import ast_nodes:*
import ast_transformation:*
import interpreter:*
import hash_set:*
import pass_common:*
fun ctce_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_syntax: *map<*ast_node, *tree<symbol>>) {
var visited = set<*ast_node>()
var visited = hash_set<*ast_node>()
var globals = setup_globals(*name_ast_map)
var ctce_passes = vector<*ast_node>()
name_ast_map->for_each(fun(name: string, syntax_ast_pair: pair<*tree<symbol>,*ast_node>) {

3
stdlib/defer_lower.krak
View File

@@ -8,12 +8,13 @@ import mem:*
import io:*
import ast_nodes:*
import ast_transformation:*
import hash_set:*
import pass_common:*
fun defer_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_syntax: *map<*ast_node, *tree<symbol>>) {
var enclosing_function_stack = stack<*ast_node>()
var visited = set<*ast_node>()
var visited = hash_set<*ast_node>()
name_ast_map->for_each(fun(name: string, syntax_ast_pair: pair<*tree<symbol>,*ast_node>) {
var defer_triple_stack = stack<stack<stack<*ast_node>>>()
var loop_stack = stack(-1)

90
stdlib/hash_set.krak
View File

@@ -21,7 +21,7 @@ fun from_vector<T>(items: vector::vector<T>): hash_set<T> {
}
obj hash_set<T> (Object, Serializable) {
var data: hash_map::hash_map<T>
var data: hash_map::hash_map<T,bool>
fun construct(): *hash_set<T> {
data.construct()
return this
@@ -42,10 +42,10 @@ obj hash_set<T> (Object, Serializable) {
fun unserialize(it: ref vector::vector<char>, pos: int): int {
return data.unserialize(it, pos)
}
fun operator==(rhs: ref hash_set<T>): bool {
if (size() != rhs.size())
return false
return !data.any_true( fun(item: T): bool return !rhs.contains(item); )
// the old unnecessary template to prevent generation
// if not used trick (in this case, changing out U with V)
fun operator==<V>(other: ref hash_set<V>): bool {
return data == other.data
}
fun operator!=(rhs: ref hash_set<T>): bool {
return ! (*this == rhs)
@@ -56,58 +56,58 @@ obj hash_set<T> (Object, Serializable) {
fun size():int {
return data.size
}
fun contains(items: ref hash_set<T>): bool {
return items.size() == 0 || !items.any_true( fun(item: T): bool return !contains(item); )
}
/*fun contains(items: ref hash_set<T>): bool {*/
/*return items.size() == 0 || !items.any_true( fun(item: T): bool return !contains(item); )*/
/*}*/
fun contains(item: ref T): bool {
return data.contains_key(item)
}
fun operator+=(item: ref T) {
add(item)
}
fun operator+=(items: ref hash_set<T>) {
add(items)
}
fun operator+(items: ref hash_set<T>): hash_set<T> {
var to_ret.copy_construct(this): hash_set<T>
to_ret.add(items)
return to_ret
}
/*fun operator+=(items: ref hash_set<T>) {*/
/*add(items)*/
/*}*/
/*fun operator+(items: ref hash_set<T>): hash_set<T> {*/
/*var to_ret.copy_construct(this): hash_set<T>*/
/*to_ret.add(items)*/
/*return to_ret*/
/*}*/
fun add(item: ref T) {
if (!contains(item))
data.set(item,true)
}
fun add_all(items: ref hash_set<T>) {
add(items)
}
fun add(items: ref hash_set<T>) {
items.for_each( fun(item: ref T) add(item); )
}
/*fun add_all(items: ref hash_set<T>) {*/
/*add(items)*/
/*}*/
/*fun add(items: ref hash_set<T>) {*/
/*items.for_each( fun(item: ref T) add(item); )*/
/*}*/
fun remove(item: ref T) {
data.remove(item)
}
fun for_each(func: fun(ref T):void) {
data.for_each(func)
}
fun for_each(func: fun(T):void) {
data.for_each(func)
}
fun any_true(func: fun(T):bool):bool {
return data.any_true(func)
}
fun reduce<U>(func: fun(T,U): U, initial: U): U {
return data.reduce(func, initial)
}
fun flatten_map<U>(func: fun(T):hash_set<U>):hash_set<U> {
var newSet.construct(size()): hash_set<U>
for (var i = 0; i < size(); i++;)
func(data[i]).for_each(fun(item: ref U) newSet.add(item);)
return newSet
}
fun filter(func: fun(T):bool):hash_set<T> {
var newSet.construct(): hash_set<T>
newSet.data = data.filter(func)
return newSet
}
/*fun for_each(func: fun(ref T):void) {*/
/*data.for_each(func)*/
/*}*/
/*fun for_each(func: fun(T):void) {*/
/*data.for_each(func)*/
/*}*/
/*fun any_true(func: fun(T):bool):bool {*/
/*return data.any_true(func)*/
/*}*/
/*fun reduce<U>(func: fun(T,U): U, initial: U): U {*/
/*return data.reduce(func, initial)*/
/*}*/
/*fun flatten_map<U>(func: fun(T):hash_set<U>):hash_set<U> {*/
/*var newSet.construct(size()): hash_set<U>*/
/*for (var i = 0; i < size(); i++;)*/
/*func(data[i]).for_each(fun(item: ref U) newSet.add(item);)*/
/*return newSet*/
/*}*/
/*fun filter(func: fun(T):bool):hash_set<T> {*/
/*var newSet.construct(): hash_set<T>*/
/*newSet.data = data.filter(func)*/
/*return newSet*/
/*}*/
}

2
stdlib/node_counter.krak
View File

@@ -22,7 +22,7 @@ fun node_counter_test(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>,
}
fun node_counter_helper(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_syntax: *map<*ast_node, *tree<symbol>>): int {
var counter = 0
var visited = set<*ast_node>()
var visited = hash_set<*ast_node>()
name_ast_map->for_each(fun(name: string, syntax_ast_pair: pair<*tree<symbol>,*ast_node>) {
var helper = fun(node: *ast_node, parent_chain: *stack<*ast_node>) {
counter++

24
stdlib/obj_lower.krak
View File

@@ -9,6 +9,7 @@ import io:*
import ast_nodes:*
import ast_transformation:*
import pass_common:*
import hash_set:*
// Here's how we lower objects
// 1 first, we make sure that all functions, if statments, while loops and for loops have code blocks
@@ -21,10 +22,10 @@ import pass_common:*
// temporaries.
// 3 this is also when we add in defer destructs for function parameters (inside the function) and declaration statements
fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_syntax: *map<*ast_node, *tree<symbol>>) {
var visited1 = set<*ast_node>()
var visited2 = set<*ast_node>()
var visited3 = set<*ast_node>()
var functions_visited_for_construct_in_destruct_out = set<*ast_node>()
var visited1 = hash_set<*ast_node>()
var visited2 = hash_set<*ast_node>()
var visited3 = hash_set<*ast_node>()
var functions_visited_for_construct_in_destruct_out = hash_set<*ast_node>()
name_ast_map->for_each(fun(name: string, syntax_ast_pair: pair<*tree<symbol>,*ast_node>) {
// Pass 1
var ensure_block_and_munge = fun(node: *ast_node, parent_chain: *stack<*ast_node>) {
@@ -48,7 +49,7 @@ fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
}
ast_node::for_loop(backing) {
if (!is_code_block(backing.body)) backing.body = ast_code_block_ptr(backing.body)
add_before_in(backing.init, node, parent_chain->top())
add_before_in(backing.init, node, parent_chain->top())
backing.init = null<ast_node>()
// the do_update goes in the block above the for
var update_ident = ast_identifier_ptr("do_update", type_ptr(base_type::boolean()), parent_chain->top())
@@ -73,7 +74,7 @@ fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
}
run_on_tree(ensure_block_and_munge, empty_pass_second_half, syntax_ast_pair.second, &visited1)
// Pass 2
var short_circut_op: fun(*ast_node,*stack<*ast_node>,*set<*ast_node>): bool = fun(node: *ast_node, parent_chain: *stack<*ast_node>, visited: *set<*ast_node>): bool {
var short_circut_op: fun(*ast_node,*stack<*ast_node>,*hash_set<*ast_node>): bool = fun(node: *ast_node, parent_chain: *stack<*ast_node>, visited: *hash_set<*ast_node>): bool {
match(*node) {
ast_node::function_call(backing) {
var func_name = string()
@@ -83,7 +84,7 @@ fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
|| func_name == "<" || func_name == ">" || func_name == "<=" || func_name == ">="
|| func_name == "==" || func_name == "!=" || func_name == "%" || func_name == "^"
|| func_name == "|" || func_name == "&" || func_name == "." || func_name == "->"
|| func_name == "." || func_name == "->" || func_name == "[]" || func_name == "++p" || func_name == "--p"
|| func_name == "." || func_name == "->" || func_name == "[]" || func_name == "++p" || func_name == "--p"
|| func_name == "*" || func_name == "&"
)
return true
@@ -102,9 +103,6 @@ fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
add_before_in(short_circuit_if, parent_chain->from_top(enclosing_block_idx-1), parent_chain->from_top(enclosing_block_idx))
replace_with_in(node, short_circuit_result, parent_chain)
var shorter_tree = stack_from_vector( parent_chain->data.slice(0, parent_chain->size()-enclosing_block_idx))
/*visited->add(short_circuit_result)*/
/*visited->add(short_circuit_declaration)*/
/*visited->add(short_circuit_if)*/
run_on_tree_helper(short_circut_op, empty_pass_second_half, short_circuit_declaration, &shorter_tree, visited)
run_on_tree_helper(short_circut_op, empty_pass_second_half, short_circuit_if, &shorter_tree, visited)
return false
@@ -124,7 +122,7 @@ fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
|| func_name == "<" || func_name == ">" || func_name == "<=" || func_name == ">="
|| func_name == "==" || func_name == "!=" || func_name == "%" || func_name == "^"
|| func_name == "|" || func_name == "&" || func_name == "." || func_name == "->"
|| func_name == "." || func_name == "->" || func_name == "[]" || func_name == "++p" || func_name == "--p"
|| func_name == "." || func_name == "->" || func_name == "[]" || func_name == "++p" || func_name == "--p"
|| func_name == "*" || func_name == "&" || func_name == "||" || func_name == "&&"
|| func_name == "!"
)
@@ -162,7 +160,7 @@ fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
var declaration = ast_declaration_statement_ptr(temp_return, node, false)
add_before_in(declaration, replace_before, replace_in)
add_before_in(ast_defer_statement_ptr(make_method_call(temp_return, "destruct", vector<*ast_node>())),
replace_before, replace_in)
replace_before, replace_in)
replace_with_in(node, temp_return, parent_chain)
}
}
@@ -194,7 +192,7 @@ fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
add_after_in(make_method_call(backing.identifier, "copy_construct", vector(make_operator_call("&", vector(temp_cpy_ctst)))),
node, parent_chain->top())
// do second so the order's right
add_after_in(declaration,
add_after_in(declaration,
node, parent_chain->top())
backing.expression = null<ast_node>()
}

13
stdlib/pass_common.krak
View File

@@ -4,6 +4,7 @@ import util:*
import vector:*
import stack:*
import string:*
import hash_set:*
fun make_this_noncached(object: *ast_node): *ast_node {
return ast_identifier_ptr("this", object->type_def.self_type->clone_with_indirection(1), object)
@@ -404,18 +405,18 @@ fun add_after_in(to_add: *ast_node, before: *ast_node, in: *ast_node) {
error(string("cannot add_after_in to ") + get_ast_name(in))
}
fun empty_pass_first_half(node: *ast_node, parent_chain: *stack<*ast_node>, visited: *set<*ast_node>): bool { return true; }
fun empty_pass_first_half(node: *ast_node, parent_chain: *stack<*ast_node>, visited: *hash_set<*ast_node>): bool { return true; }
fun empty_pass_second_half(node: *ast_node, parent_chain: *stack<*ast_node>) {}
fun run_on_tree(func_before: fun(*ast_node,*stack<*ast_node>):void, func_after: fun(*ast_node,*stack<*ast_node>):void, tree: *ast_node, visited: *set<*ast_node>)
run_on_tree(fun(n: *ast_node, s: *stack<*ast_node>, v: *set<*ast_node>): bool {func_before(n, s);return true;}, func_after, tree, visited)
fun run_on_tree(func_before: fun(*ast_node,*stack<*ast_node>):void, func_after: fun(*ast_node,*stack<*ast_node>):void, tree: *ast_node, visited: *hash_set<*ast_node>)
run_on_tree(fun(n: *ast_node, s: *stack<*ast_node>, v: *hash_set<*ast_node>): bool {func_before(n, s);return true;}, func_after, tree, visited)
fun run_on_tree(func_before: fun(*ast_node,*stack<*ast_node>,*set<*ast_node>):bool, func_after: fun(*ast_node,*stack<*ast_node>):void, tree: *ast_node, visited: *set<*ast_node>) {
fun run_on_tree(func_before: fun(*ast_node,*stack<*ast_node>,*hash_set<*ast_node>):bool, func_after: fun(*ast_node,*stack<*ast_node>):void, tree: *ast_node, visited: *hash_set<*ast_node>) {
var parent_stack = stack<*ast_node>()
run_on_tree_helper(func_before, func_after, tree, &parent_stack, visited)
}
fun run_on_tree_helper(func_before: fun(*ast_node,*stack<*ast_node>,*set<*ast_node>):bool,
fun run_on_tree_helper(func_before: fun(*ast_node,*stack<*ast_node>,*hash_set<*ast_node>):bool,
func_after: fun(*ast_node,*stack<*ast_node>):void,
node: *ast_node, parent_chain: *stack<*ast_node>, visited: *set<*ast_node>) {
node: *ast_node, parent_chain: *stack<*ast_node>, visited: *hash_set<*ast_node>) {
// So some nodes should be done regardless of weather or not we've visited them - these are the places where a more reasonable AST might use bindings, i.e. variables and functions.
if (!node || (!is_function(node) && !is_identifier(node) && visited->contains(node))) return;
visited->add(node)

3
stdlib/ref_lower.krak
View File

@@ -3,6 +3,7 @@ import tree:*
import map:*
import vector:*
import set:*
import hash_set:*
import util:*
import string:*
import mem:*
@@ -40,7 +41,7 @@ fun ref_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
var remove_ref_type_set = set<pair<string,*type>>()
var modify_reference_use_set = set<pair<*ast_node, *ast_node>>()
var modify_return_set = set<*ast_node>()
var visited = set<*ast_node>()
var visited = hash_set<*ast_node>()
name_ast_map->for_each(fun(name: string, syntax_ast_pair: pair<*tree<symbol>,*ast_node>) {
var helper_before = fun(node: *ast_node, parent_chain: *stack<*ast_node>) {
match(*node) {