From ebb34d5ba3d1f45e5d58d70d18fcc096fc58e4c4 Mon Sep 17 00:00:00 2001 From: Nathan Braswell Date: Sun, 22 Jan 2017 10:13:06 -0500 Subject: [PATCH] Replace visited list for pass_common with hash_set (which isn't complete, but has the basics) for a massive speedup (6xish) --- stdlib/adt_lower.krak | 7 ++-- stdlib/ctce_lower.krak | 3 +- stdlib/defer_lower.krak | 3 +- stdlib/hash_set.krak | 90 ++++++++++++++++++++-------------------- stdlib/node_counter.krak | 2 +- stdlib/obj_lower.krak | 24 +++++------ stdlib/pass_common.krak | 13 +++--- stdlib/ref_lower.krak | 3 +- 8 files changed, 74 insertions(+), 71 deletions(-) diff --git a/stdlib/adt_lower.krak b/stdlib/adt_lower.krak index a4ea022..c674cc9 100644 --- a/stdlib/adt_lower.krak +++ b/stdlib/adt_lower.krak @@ -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,*ast_node>>, ast_to_syntax: *map<*ast_node, *tree>) { 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,*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,*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])) } diff --git a/stdlib/ctce_lower.krak b/stdlib/ctce_lower.krak index 1a48ea6..78fa191 100644 --- a/stdlib/ctce_lower.krak +++ b/stdlib/ctce_lower.krak @@ -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,*ast_node>>, ast_to_syntax: *map<*ast_node, *tree>) { - 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,*ast_node>) { diff --git a/stdlib/defer_lower.krak b/stdlib/defer_lower.krak index be011a9..83447ae 100644 --- a/stdlib/defer_lower.krak +++ b/stdlib/defer_lower.krak @@ -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,*ast_node>>, ast_to_syntax: *map<*ast_node, *tree>) { 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,*ast_node>) { var defer_triple_stack = stack>>() var loop_stack = stack(-1) diff --git a/stdlib/hash_set.krak b/stdlib/hash_set.krak index 62d664d..845ee88 100644 --- a/stdlib/hash_set.krak +++ b/stdlib/hash_set.krak @@ -21,7 +21,7 @@ fun from_vector(items: vector::vector): hash_set { } obj hash_set (Object, Serializable) { - var data: hash_map::hash_map + var data: hash_map::hash_map fun construct(): *hash_set { data.construct() return this @@ -42,10 +42,10 @@ obj hash_set (Object, Serializable) { fun unserialize(it: ref vector::vector, pos: int): int { return data.unserialize(it, pos) } - fun operator==(rhs: ref hash_set): 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==(other: ref hash_set): bool { + return data == other.data } fun operator!=(rhs: ref hash_set): bool { return ! (*this == rhs) @@ -56,58 +56,58 @@ obj hash_set (Object, Serializable) { fun size():int { return data.size } - fun contains(items: ref hash_set): bool { - return items.size() == 0 || !items.any_true( fun(item: T): bool return !contains(item); ) - } + /*fun contains(items: ref hash_set): 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) { - add(items) - } - fun operator+(items: ref hash_set): hash_set { - var to_ret.copy_construct(this): hash_set - to_ret.add(items) - return to_ret - } + /*fun operator+=(items: ref hash_set) {*/ + /*add(items)*/ + /*}*/ + /*fun operator+(items: ref hash_set): hash_set {*/ + /*var to_ret.copy_construct(this): hash_set*/ + /*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) { - add(items) - } - fun add(items: ref hash_set) { - items.for_each( fun(item: ref T) add(item); ) - } + /*fun add_all(items: ref hash_set) {*/ + /*add(items)*/ + /*}*/ + /*fun add(items: ref hash_set) {*/ + /*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(func: fun(T,U): U, initial: U): U { - return data.reduce(func, initial) - } - fun flatten_map(func: fun(T):hash_set):hash_set { - var newSet.construct(size()): hash_set - 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 { - var newSet.construct(): hash_set - 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(func: fun(T,U): U, initial: U): U {*/ + /*return data.reduce(func, initial)*/ + /*}*/ + /*fun flatten_map(func: fun(T):hash_set):hash_set {*/ + /*var newSet.construct(size()): hash_set*/ + /*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 {*/ + /*var newSet.construct(): hash_set*/ + /*newSet.data = data.filter(func)*/ + /*return newSet*/ + /*}*/ } diff --git a/stdlib/node_counter.krak b/stdlib/node_counter.krak index 35e30b2..746c823 100644 --- a/stdlib/node_counter.krak +++ b/stdlib/node_counter.krak @@ -22,7 +22,7 @@ fun node_counter_test(name_ast_map: *map,*ast_node>>, } fun node_counter_helper(name_ast_map: *map,*ast_node>>, ast_to_syntax: *map<*ast_node, *tree>): 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,*ast_node>) { var helper = fun(node: *ast_node, parent_chain: *stack<*ast_node>) { counter++ diff --git a/stdlib/obj_lower.krak b/stdlib/obj_lower.krak index 9c2136c..4fc458a 100644 --- a/stdlib/obj_lower.krak +++ b/stdlib/obj_lower.krak @@ -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,*ast_node>>, ast_to_syntax: *map<*ast_node, *tree>) { - 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,*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,*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() // 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,*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,*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,*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,*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,*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,*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() } diff --git a/stdlib/pass_common.krak b/stdlib/pass_common.krak index 88319df..502b55d 100644 --- a/stdlib/pass_common.krak +++ b/stdlib/pass_common.krak @@ -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) diff --git a/stdlib/ref_lower.krak b/stdlib/ref_lower.krak index f6ec29d..c3a66ba 100644 --- a/stdlib/ref_lower.krak +++ b/stdlib/ref_lower.krak @@ -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,*ast_node>>, ast_to_ var remove_ref_type_set = set>() var modify_reference_use_set = set>() 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,*ast_node>) { var helper_before = fun(node: *ast_node, parent_chain: *stack<*ast_node>) { match(*node) {