added benchmark results to README

README.md

@@ -117,6 +117,55 @@ big set of parameters.
 
 `utils/plot_results.py` generates several plots of the results.
 
+# Results
+
+These are some quick tests, further results will be presented later.
+Everything was run on a Thinkpad X260 laptop with an Intel i7-6600U CPU @ 2.60GHz
+processor.
+Each test used the same 1000 queries.
+Rust v1.57.0 was used for all tests.
+
+The ALT variants were used with the 4 best landmarks.
+Further tests on the performance of more landmarks will be presented laster.
+The set of 44 handpicked landmarks were spread around the extremeties of the
+continents and into "dead ends" like the Mediteranean and the Gulf of Mexico
+with the goal to provide landmarks that are "behind" the source or target
+node.
+
+All benchmarks were run on the provided benchmark graph.
+
+## raw data:
+```
+# name, (avg. heap pops per query, avg. time)
+{'astar': (155019.451, 0.044386497025),
+ 'dijkstra': (423046.796, 0.058129875474999995),
+ 'greedy_32': (42514.751, 0.013299024275000002),
+ 'greedy_64': (35820.461, 0.011887869759),
+ 'handpicked_44': (70868.721, 0.01821366828),
+ 'random_32': (58830.082, 0.016845884717),
+ 'random_64': (51952.261, 0.015234422699)}
+```
+
+## Interpretation
+
+Dijkstra needs ~58ms per route, while the best version is greedy\_64 (that is
+with 64 landmarks) needs only 12 seconds, which is ~5 times faster.
+We also see, that the greedy versions perform slightly better than their
+random counterparts with the same amount of nodes.
+While the 44 handpicked landmarks outperformed A\* and Dijkstra, they are beaten
+by both the random and greedy landmark selections which had fewer nodes.
+
+## Memory Consumption
+
+The landmarks are basically arrays of the cost to each node.
+Since the distances are currently calculates with 64 bit integers
+each landmark needs 8 byte per node in the graph.
+With a graph that has about 700k nodes this leads to ~5.5MB of memory per
+landmark.
+So 64 landmarks need ~350MB of memory.
+
+One could also use 32 bit integers which would half the memory requirements.
+
 # References
 
 [1](Computing the Shortest Path: A\* meets Graph Theory, A. Goldberg and C. Harrelson, Microsoft Research, Technical Report MSR-TR-2004-24, 2004)