Improve tiling speed (#195)

* Add a way to run tippecanoe single-threaded for profiling

* Do less work when the tilestats sample values list is already full

* Save a copy when retrieving the attribute key

* Fewer atomic operations

* Move string hashing from mbtiles to text

* Only do approximate attribute deduplication when writing tiles

* Feature dropping tests are sensitive to exact tile size

* All tile creators now create a string pool for the tile

* Features clipped away to nothing should not participate in that tile

* Revert "Only do approximate attribute deduplication when writing tiles"

This reverts commit c42b34b498.

* Also revert the related test changes

* Revert "Revert "Only do approximate attribute deduplication when writing tiles""

This reverts commit 18509876c3.

* Be more specific about the string hash function

* Use fnv1a instead of std::hash for everything

* Reduce the chance of hash collisions

* Stick a hash search on the front of the tree search in addpool

* Eliminate repeated hashing of the same string

* Switch instead of ifs in json parsing

* A few more cases to populate the hash in addpool

* Store the hash in the tree instead of recalculating

* Add explanatory comment for mysterious argument

* Fewer copies in attribute stringification

* Clean up ancient weirdness in JSON attribute stringification

* More serial_val cleanup

* Pass a serial_feature to rewrite instead of many broken-down arguments

* Get rid of the multiple geometries within `partial`

* Revert "Pass a serial_feature to rewrite instead of many broken-down arguments"

This reverts commit 6f4ab9b725.

* Goodbye, struct coalesce

* Revert "Features clipped away to nothing should not participate in that tile"

This reverts commit 124462fbdc.

* Migrating fields from partial to serial_feature

* Name reconciliation between serial_feature and partial

* Replace struct partial with an augmented serial_feature

* Fix some overzealous search-and-replace renaming

* Don't say struct so often

* Remove more of the former partial construction

* Commenting and cleaning up

* Trying again to avoid all these arguments to rewrite

* I swear I did this same thing before and it didn't work.

* More rewrite cleanup

* Exile --detect-shared-borders to its own file

* Add missing headers

* More commenting and cleanup

* More comments

* Sprinkle consts around

* Emplacing and std::moving

* More cleanup

* That shouldn't have worked after a std::move

* Don't need to allocate memory to compare keys

* Reduce use of the global string pool in tiling

* Another avoidable mvt_value construction

* Further reduction to explicit string pool passing

* These reverses are no longer optimizations

* These layernames can all be references

* Don't drag an unused layername string around with every feature

* Heed a compiler warning about potential buffer overflow

* Fix my confusion about which feature's string pool is relevant

* Avoid some unnecessary allocations in attribute accumulation

* Maybe faster serialization?

* Eliminate a comparison

* Do the same here

* Save a couple of allocations when parsing numbers in JSON

* Immediately assign features to layers instead of subdividing later

* Maintain tilestats for tippecanoe:retain_points_multiplier_sequence

* Crunch out more duplicate attribute values when writing out the tile

* Do tilestats for tippecanoe:retain_points_multiplier_first too

* Shell filters need to be real threads, even if nothing else does

* Simplify tippecanoe_minzoom/maxzoom representation

* Update version and changelog

mvt.cpp

@@ -15,6 +15,7 @@
 #include "milo/dtoa_milo.h"
 #include "errors.hpp"
 #include "serial.hpp"
+#include "text.hpp"
 
 mvt_geometry::mvt_geometry(int nop, long long nx, long long ny) {
 	this->op = nop;
@@ -307,9 +308,13 @@ struct sorted_value {
 	bool operator<(const sorted_value &sv) const {
 		if (val < sv.val) {
 			return true;
-		} else {
-			return false;
+		} else if (val == sv.val) {
+			if (orig < sv.orig) {
+				return true;
+			}
 		}
+
+		return false;
 	}
 };
 
@@ -376,9 +381,18 @@ std::string mvt_tile::encode() {
 		std::vector<size_t> mapping;
 		mapping.resize(sorted_values.size());
 
+		size_t value_index = 0;
 		for (size_t v = 0; v < sorted_values.size(); v++) {
-			mapping[sorted_values[v].orig] = v;
+			mapping[sorted_values[v].orig] = value_index;
 			layer_writer.add_message(4, sorted_values[v].val);
+
+			// crunch out duplicates that were missed by the hashing
+			while (v + 1 < sorted_values.size() && sorted_values[v].val == sorted_values[v + 1].val) {
+				mapping[sorted_values[v + 1].orig] = value_index;
+				v++;
+			}
+
+			value_index++;
 		}
 
 		for (size_t f = 0; f < layers[i].features.size(); f++) {
@@ -592,41 +606,23 @@ std::string mvt_value::toString() const {
 }
 
 void mvt_layer::tag(mvt_feature &feature, std::string const &key, mvt_value const &value) {
-	size_t ko, vo;
-
-	// initialize lazily the first time anyone tags an attribute
-	// to save the time of doing it in decode, which never actually matters.
-	// only tile writers actually need this.
-	if (key_map.size() == 0) {
-		for (size_t i = 0; i < keys.size(); i++) {
-			key_map.emplace(keys[i], i);
-		}
-		for (size_t i = 0; i < values.size(); i++) {
-			value_map.emplace(values[i], i);
-		}
-	}
-
-	std::unordered_map<std::string, size_t>::iterator ki = key_map.find(key);
-	std::unordered_map<mvt_value, size_t>::iterator vi = value_map.find(value);
-
-	if (ki == key_map.end()) {
-		ko = keys.size();
+	size_t key_hash = fnv1a(key) % key_dedup.size();
+	if (key_dedup[key_hash] >= 0 &&
+	    keys[key_dedup[key_hash]] == key) {
+	} else {
+		key_dedup[key_hash] = keys.size();
 		keys.push_back(key);
-		key_map.emplace(key, ko);
-	} else {
-		ko = ki->second;
 	}
+	feature.tags.push_back(key_dedup[key_hash]);
 
-	if (vi == value_map.end()) {
-		vo = values.size();
+	size_t value_hash = std::hash<mvt_value>()(value) % value_dedup.size();
+	if (value_dedup[value_hash] >= 0 &&
+	    values[value_dedup[value_hash]] == value) {
+	} else {
+		value_dedup[value_hash] = values.size();
 		values.push_back(value);
-		value_map.emplace(value, vo);
-	} else {
-		vo = vi->second;
 	}
-
-	feature.tags.push_back(ko);
-	feature.tags.push_back(vo);
+	feature.tags.push_back(value_dedup[value_hash]);
 }
 
 bool is_integer(const char *s, long long *v) {
@@ -705,8 +701,9 @@ bool is_unsigned_integer(const char *s, unsigned long long *v) {
 // the type (int, uint, sint, float, or double) that will give the
 // smallest representation in the tile without losing precision,
 // regardless of how the value was represented in the original source.
-mvt_value stringified_to_mvt_value(int type, const char *s) {
+mvt_value stringified_to_mvt_value(int type, const char *s, std::shared_ptr<std::string> const &tile_stringpool) {
 	mvt_value tv;
+	tv.s = tile_stringpool;
 
 	switch (type) {
 	case mvt_double: {