From bfc3b72b00a89a972ba960119cb4f0d09cddc720 Mon Sep 17 00:00:00 2001 From: Nathan Braswell Date: Fri, 22 Apr 2016 02:58:14 -0400 Subject: [PATCH] Implement a hash_map and swap gss over to use it, making self-compilation 10 seconds faster on my laptop. captain.sh has been extended with the ability to bootstrap over any number of git commits. --- captain.sh | 84 ++++++++++++++++++++++++++++++-------------- stdlib/hash_map.krak | 41 +++++++++++++++------ stdlib/parser.krak | 4 +-- stdlib/util.krak | 4 +-- 4 files changed, 93 insertions(+), 40 deletions(-) diff --git a/captain.sh b/captain.sh index 06ff8e7..bf8bfc4 100755 --- a/captain.sh +++ b/captain.sh @@ -1,25 +1,33 @@ #!/bin/bash kraken="kraken" -bootstrap_commits=(cf46fb13afe66ba475db9725e9269c9c1cd3bbc3) +bootstrap_commits=(cf46fb13afe66ba475db9725e9269c9c1cd3bbc3 2cd43e5a217318c70097334b3598d2924f64b362) if [[ $1 == "clean" ]] then rm ${kraken} rm ${kraken}_bac rm ${kraken}_deprecated + rm ${kraken}_bootstrap rm -rf bootstrap_kalypso else if [[ $1 == "backup" ]] then rm ${kraken} fi + if [[ $1 == "from_old" ]] + then + rm ${kraken} + rm ${kraken}_bac + rm ${kraken}_deprecated + fi if [[ $1 == "rebuild" ]] then rm ${kraken} rm ${kraken}_bac rm ${kraken}_deprecated rm ${kraken}_bootstrap + rm -rf bootstrap_kalypso fi if [ -s "$kraken" ] @@ -32,42 +40,66 @@ else then if ! [ -s "${kraken}_deprecated" ] then - echo "no ${kraken}_deprecated, bootstrapping using Cephelpod and a chain of old Kalypsos" - git clone . bootstrap_kalypso - pushd bootstrap_kalypso - git checkout ${bootstrap_commits[0]} - cp -r stdlib deprecated_compiler - cp krakenGrammer.kgm deprecated_compiler - cp kraken.krak deprecated_compiler - pushd deprecated_compiler - mkdir build - pushd build - cmake .. - make - popd - mkdir build_kraken - mv kraken.krak build_kraken - pushd build_kraken - ../build/kraken kraken.krak - popd - popd - pushd deprecated_compiler/build_kraken/kraken - sh kraken.sh - popd - cp deprecated_compiler/build_kraken/kraken/kraken ../${kraken}_bootstrap - popd - # Now make + echo "no ${kraken}_deprecated, bootstrapping using kraken_bootstrap" + if ! [ -s "${kraken}_bootstrap" ] + then + echo "no ${kraken}_bootstrap, bootstrapping using Cephelpod and a chain of old Kalypsos" + git clone . bootstrap_kalypso + pushd bootstrap_kalypso + git checkout ${bootstrap_commits[0]} + cp -r stdlib deprecated_compiler + cp krakenGrammer.kgm deprecated_compiler + cp kraken.krak deprecated_compiler + pushd deprecated_compiler + mkdir build + pushd build + cmake .. + make + popd + mkdir build_kraken + mv kraken.krak build_kraken + pushd build_kraken + ../build/kraken kraken.krak + popd + popd + pushd deprecated_compiler/build_kraken/kraken + sh kraken.sh + popd + cp deprecated_compiler/build_kraken/kraken/kraken ./${kraken}_bootstrap + # loop through the chain + for ((i=1; i < ${#bootstrap_commits[@]}; i++)) + do + echo "building kalypso bootstrap part $i" + echo "commit hash: ${bootstrap_commits[$i]}" + mv ./krakenGrammer.kgm krakenGrammer.kgm_old + git checkout ${bootstrap_commits[$i]} + mv ./krakenGrammer.kgm krakenGrammer.kgm_new + mv ./krakenGrammer.kgm_old krakenGrammer.kgm + ./${kraken}_bootstrap kraken.krak ${kraken}_bootstrap + mv ./krakenGrammer.kgm_new krakenGrammer.kgm + done + popd # out of bootstrap + fi + echo "making kraken_deprecated - the first current Kraken version, but built with an old compiler" + + # Now make real mv ./krakenGrammer.kgm krakenGrammer.kgm_new + mv ./krakenGrammer.kgm.comp_new krakenGrammer.kgm.comp_new_new cp bootstrap_kalypso/krakenGrammer.kgm ./ + cp bootstrap_kalypso/krakenGrammer.kgm.comp_new ./ + cp bootstrap_kalypso/${kraken}_bootstrap ./${kraken}_bootstrap ./${kraken}_bootstrap kraken.krak ${kraken}_deprecated mv ./krakenGrammer.kgm_new krakenGrammer.kgm + mv ./krakenGrammer.kgm.comp_new_new krakenGrammer.kgm.comp_new else echo "${kraken}_deprecated exists, calling" fi + echo "making kraken_bac, a current compiler built with kraken_deprecated" ./${kraken}_deprecated kraken.krak ${kraken}_bac else echo "${kraken}_bac exists, calling" fi + echo "making kraken, the real current compiler built with kraken_bac" ./${kraken}_bac kraken.krak ${kraken} fi fi diff --git a/stdlib/hash_map.krak b/stdlib/hash_map.krak index f012b78..16084c9 100644 --- a/stdlib/hash_map.krak +++ b/stdlib/hash_map.krak @@ -22,17 +22,29 @@ obj hash_map (Object, Serializable) { data.construct() data.add(map::map()) size = 0 + /*io::print("Constructed hash_map, this: ")*/ + /*io::println((this) cast int)*/ + /*io::print("size of data:")*/ + /*io::println(data.size)*/ return this } fun copy_construct(old: *hash_map) { data.copy_construct(&old->data) size = old->size + /*io::print("Copy constructed hash_map, this: ")*/ + /*io::println((this) cast int)*/ + /*io::print("new size of data:")*/ + /*io::println(data.size)*/ + /*io::print("old size of data:")*/ + /*io::println(old->data.size)*/ } fun operator=(rhs: hash_map) { destruct() copy_construct(&rhs) } fun destruct() { + /*io::print("destructed hash_map, this: ")*/ + /*io::println((this) cast int)*/ data.destruct() } fun serialize(): vector::vector { @@ -49,19 +61,26 @@ obj hash_map (Object, Serializable) { return data == other.data } fun set(key: T, value: U) { + /*io::print("doing set! this:")*/ + /*io::println((this) cast int)*/ + /*io::print("size of data:")*/ + /*io::println(data.size)*/ var key_hash = util::hash(key) - if (!data[key_hash%data.size].contains_key(key)) + if (!data[key_hash%data.size].contains_key(key)) { size++ - data[key_hash%data.size].set(key, value) - if (size > data.size) { - var new_data = vector::vector>() - for (var i = 0; i < size*2; i++;) - new_data.addEnd(map::map()) - for_each(fun(key: T, value: U) { - new_data[util::hash(key)%new_data.size].set(key, value) - }) - data = new_data + if (size > data.size) { + /*io::print("rehashing to: ")*/ + /*io::println(size*2)*/ + var new_data = vector::vector>() + for (var i = 0; i < size*2; i++;) + new_data.addEnd(map::map()) + for_each(fun(key: T, value: U) { + new_data[util::hash(key)%new_data.size].set(key, value) + }) + data = new_data + } } + data[key_hash%data.size].set(key, value) } fun get(key: T): ref U { return data[util::hash(key)%data.size].get(key) @@ -103,6 +122,8 @@ obj hash_map (Object, Serializable) { } fun clear() { data.clear() + size = 0 + data.add(map::map()) } } diff --git a/stdlib/parser.krak b/stdlib/parser.krak index b48b3c8..442ff9a 100644 --- a/stdlib/parser.krak +++ b/stdlib/parser.krak @@ -405,8 +405,8 @@ obj parser (Object) { obj gss (Object) { var data: vector>> - var edges: map< pair<*tree, *tree>, *tree > - /*var edges: hash_map< pair<*tree, *tree>, *tree >*/ + /*var edges: map< pair<*tree, *tree>, *tree >*/ + var edges: hash_map< pair<*tree, *tree>, *tree > fun construct(): *gss { data.construct() diff --git a/stdlib/util.krak b/stdlib/util.krak index a44b9b0..deb3a93 100644 --- a/stdlib/util.krak +++ b/stdlib/util.krak @@ -95,8 +95,8 @@ obj pair (Object, Serializable, Hashable) { return second_pair.second } - /*fun hash():int return hash(first) ^ hash(second)*/ - fun hash():int return 0 + fun hash():int return hash(first) ^ hash(second) + /*fun hash():int return 0*/ // the old unnecessary template to prevent generation // if not used trick (in this case, changing out U with V)