Update site

Author: jankotek

README!! renamed to README.md

@@ -12,18 +12,22 @@ To generate PDF one has to install texlive packages.
 
     sudo apt-get install texlive-latex-base texlive-fonts-recommended texlive-latex-extra
 
-Than run
+Script also uses Maven to execute some code and verify tests. 
 
-    ./pdf
+    sudo apt-get install maven
+    
+It might also depend on latest version of MapDB, so install it into local maven repo:
+    
+    sudo apt-get install git
+    git clone https://github.com/jankotek/mapdb.git
+    cd mapdb
+    mvn install -DskipTests=true
 
+Finally generate html:
 
-And generate html. It depends on PDF and MapDB source code. Result will be placed in _build/html
+    ./make.sh
 
-    make clean html
-
-To publish local changes checkout `gh-pages` branch into `../gh-pages/` folder and run publish. It will ask for
-github login:
-
-    ./publish
+And publish it (if you have a rights)
 
+    ./publish.sh
 

benchmark.properties

@@ -0,0 +1,39 @@
+#mapdb benchmark
+#Tue Mar 08 17:46:20 EET 2016
+BTreeMap_get=18495
+BTreeMap_heap_get=2425
+BTreeMap_heap_insert=5150
+BTreeMap_heap_update=4616
+BTreeMap_insert=38526
+BTreeMap_update=25582
+ConcurrentHashMap_get=217
+ConcurrentHashMap_insert=636
+ConcurrentHashMap_update=450
+ConcurrentSkipListMap_get=1592
+ConcurrentSkipListMap_insert=3022
+ConcurrentSkipListMap_update=1730
+HTreeMap_get=14895
+HTreeMap_heap_get=7021
+HTreeMap_heap_insert=12169
+HTreeMap_heap_update=8246
+HTreeMap_insert=21026
+HTreeMap_update=24809
+MapDB2_BTreeMap_get=18871
+MapDB2_BTreeMap_insert=40398
+MapDB2_BTreeMap_update=29766
+MapDB2_HTreeMap_get=22344
+MapDB2_HTreeMap_insert=31848
+MapDB2_HTreeMap_update=24202
+MapMemoryUsage\#BTreeMap=27800000
+MapMemoryUsage\#BTreeMap_heap=139500000
+MapMemoryUsage\#BTreeMap_pump=271900000
+MapMemoryUsage\#ConcurrentHashMap=44100000
+MapMemoryUsage\#ConcurrentSkipListMap=46700000
+MapMemoryUsage\#HTreeMap=40100000
+MapMemoryUsage\#HTreeMap_heap=60600000
+MapMemoryUsage\#MapDB2_BTreeMap=125800000
+MapMemoryUsage\#MapDB2_HTreeMap=20100000
+MapMemoryUsage\#SortedTableMap=291500000
+SortedTableMapBenchmark_get=4908
+org.mapdb.benchmark.ExpiryBench.createTTL=56032
+org.mapdb.benchmark.IndexTreeLongLongMapBench.create=3024

benchmarks.rst

@@ -0,0 +1,76 @@
+In-memory benchmarks
+======================
+
+This benchmark compares different Map implementations. We try to keep this test fair, no trick or extra tuning.
+Also dataset is small with no GC overhead.
+
+Benchmark source is in `Github repo <https://github.com/jankotek/mapdb-benchmarks>`_.
+Please send Pull Request if you have improvements.
+All tests ran on Linux with 64bit JDK8.
+
+Maps
+--------------
+
+There are six maps in this test. All tests work on Map with 10 million entries to minimize GC overhead,
+Key is 8-byte long, value is 16-byte UUID.
+Small objects were chosen to better illustrate overhead of internal Map structures (nodes, hash table..)
+
+HTreeMap is concurrent HashMap implementation from MapDB. It is optimized for bigger keys and large number of entries.
+It has some extra features such as entry expiration with TTL or maximal size.
+
+BTreeMap is concurrent TreeMap implementation from MapDB. It is optimized for minimal space usage and for small keys.
+It has features to redoce memory and space usage.
+
+MapDB serializes all data into in-memory binary store backed by ``byte[]``. This storage is not limited by GC
+ and ``DirectByteBuffer`` version was tested on half-terabyte of memory.
+
+There is also ``_heap`` mode where MapDB  stores all data on-heap using pointers and object instances.
+There is no serialization involved.
+This mode is usually faster for smaller sets, but is limited by Garbage Collection.
+
+Memory usage
+~~~~~~~~~~~~~~
+
+This chart shows how much entries ``Map<Long,UUID>`` can fit into 5GB of heap memory.
+JVM starts with 5GB maximal heap size (``-Xmx5G``), entries are added  until JVM terminates with ``OutOfMemoryException``.
+
+.. centered:: **Number of entries inserted into Map with 5GB heap, before JVM runs out of memory (higher is better)**
+.. image:: target/charts/maps_memory_usage.png
+
+ConcurrentHashMap and ConcurrentSkipListMap are bundled with Java. Their both consume about the same amount of memory.
+
+BTreeMap should have in theory very good space usage. However underlying store is too fragmented after frequent updates,
+this bug should be solved soon. ``BTreeMap_pump`` shows best case for BTreeMap, with no fragmentation.
+
+``BTreeMap_heap`` is on-heap version of BTreeMap. It uses specialized node representation
+(``Long[]`` and ``UUID[]`` are internally stored in ``long[]``) and that makes it space efficient.
+
+HTreeMap is not yet optimized for space usage, no surprise here.
+
+SortedTableMap is very space efficient after compaction.
+
+
+Random updates
+~~~~~~~~~~~~~~~~~
+
+.. centered:: **Time to update 100M random keys on Map with 100M entries (smaller is better)**
+.. image:: target/charts/maps_update.png
+
+``ConcurrentHashMap`` in this case rocks .
+
+``HTreeMap`` and ``BTreeMap`` are relatively slow. Optimizations are planned for M4.
+
+Random get
+~~~~~~~~~~~~~~~~~
+
+.. centered:: **Time to get 100M random keys on Map with 100M entries (smaller is better)**
+.. image:: target/charts/maps_get.png
+
+``ConcurrentHashMap`` rocks again.
+
+``BTreeMap_heap`` takes advantage of specialization (it uses ``long[]`` instead of ``Long[]`` in BTree Nodes).
+
+``HTreeMap`` and ``BTreeMap`` are relatively slow. Optimizations are planned for M4.
+
+
+