Improve error messages by the compiler

if the number of arguments doesn't match what is expected.
WIP interface
2023-11-01 11:14:27 +01:00 · 2023-11-01 11:14:27 +01:00 · 2023-11-01 11:13:54 +01:00 · 2023-10-21 19:05:08 +02:00 · 2023-10-20 00:02:38 +02:00 · 2023-10-19 22:54:51 +02:00
201 changed files with 47057 additions and 13643 deletions
@@ -0,0 +1,153 @@
+name: C/C++ CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        platform: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.platform }}
+    
+    steps:
+    - uses: actions/checkout@v3
+    - name: CPU Information
+      run:  lscpu || sysctl -a|grep cpu || echo "CPU information not available"
+    - name: make check C99
+      run: make clean && make check -j 2 CC="cc -std=c99 -Wno-unknown-warning-option -Werror"
+    - name: make check C11
+      working-directory: ./tests
+      run: make clean && make check -j 2 CC="cc -std=c11 -Wno-unknown-warning-option -Werror"
+    - name: make check C++
+      working-directory: ./tests
+      run: make clean && make check -j 2 CC="c++ -std=c++11"
+
+  build_linux32:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - uses: actions/checkout@v3
+    - name: update package list
+      run: sudo apt-get update
+    - name: install multilib
+      run: sudo apt-get install gcc-multilib g++-multilib
+    - name: CPU Information
+      run:  lscpu || echo "CPU information not available"
+    - name: make check C99 (32bits)
+      working-directory: ./tests
+      run: make clean && make check -j 2 CC="gcc -m32 -std=c99 -Wno-unknown-warning-option -Werror"
+    - name: make check C11 (32bits)
+      working-directory: ./tests
+      run: make clean && make check -j 2 CC="gcc -m32 -std=c11 -Wno-unknown-warning-option -Werror"
+    - name: make check C++ (32 bits)
+      working-directory: ./tests
+      run: make clean && make check -j 2 CC="g++ -m32 -std=c++11 -Wno-unknown-warning-option "
+    - name: make check against C++ STL
+      working-directory: ./tests
+      run: make clean && make check-stl -j 2
+ 
+  build_linux_tcc:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - uses: actions/checkout@v3
+    - name: CPU Information
+      run:  lscpu || echo "CPU information not available"
+    - name: Clone TCC
+      shell: bash
+      run:  git clone https://repo.or.cz/tinycc.git
+    - name: Configure, build & install TCC
+      shell: bash
+      run:  cd tinycc && ./configure --prefix=/tmp/tcc && make && make install
+    - name: make depend
+      shell: bash
+      run: make depend
+    - name: make check
+      shell: bash
+      run: make CC="/tmp/tcc/bin/tcc -std=c99" check
+
+  build_linux_sanitize:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - uses: actions/checkout@v3
+    - name: make sanitize
+      working-directory: ./tests
+      run: make sanitize -j 2
+
+  build_windows_mingw:
+    runs-on: windows-latest
+    
+    steps:
+    - uses: actions/checkout@v3
+    - name: make check
+      shell: bash
+      run: mingw32-make -j 2 CC="gcc -std=c99 -D__USE_MINGW_ANSI_STDIO=1" check
+
+  build_windows_msys2:
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: msys2 {0}    
+    steps:
+    - uses: actions/checkout@v3
+    - uses: msys2/setup-msys2@v2
+      with:
+          msystem: MINGW64
+          update: true
+          install: git mingw-w64-x86_64-toolchain make
+    - name: make check
+      run: make -j 2 CC="gcc -std=c99 -D__USE_MINGW_ANSI_STDIO=1" check
+
+  build_windows_visual:
+    runs-on: windows-latest
+    
+    steps:
+    - uses: actions/checkout@v3
+    - name: make check
+      shell: cmd
+      working-directory: ./tests
+      run: Make-check-cl.bat cl
+      
+  build_windows_clang_cl:
+    runs-on: windows-latest
+    
+    steps:
+    - uses: actions/checkout@v3
+    - name: make check
+      shell: cmd
+      working-directory: ./tests
+      run: Make-check-cl.bat clang-cl
+
+  build_freebsd:
+    runs-on: macos-12
+    steps:
+    - uses: actions/checkout@v3
+    - name: Test in FreeBSD
+      id: test
+      uses: vmactions/freebsd-vm@v0
+      with:
+        usesh: true
+        run: |
+             freebsd-version
+             cd tests
+             make check -j 2 CC="cc -std=c99 -Wno-unknown-warning-option -Werror" && make clean && make check -j 2 CC="cc -std=c11 -Wno-unknown-warning-option -Werror" LDFLAGS="-lstdthreads" && make clean
+
+    # The host should always be linux
+  build_aarch64:
+    runs-on: ubuntu-latest
+    name: Build on aarch64
+    steps:
+      - uses: actions/checkout@v3
+      - uses: uraimo/run-on-arch-action@v2.5.0
+        name: Run commands on aarch64
+        id: make
+        with:
+          arch: aarch64
+          distro: bullseye
+          shell: /bin/sh
+          run: |
+            apt-get update -q -y
+            apt-get install -q -y  build-essential git gcc
+            lscpu
+            cd tests && make check -j 2 && make clean
@@ -0,0 +1,53 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+name: "CodeQL"
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [master]
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        # Override automatic language detection by changing the below list
+        # Supported options are ['csharp', 'cpp', 'go', 'java', 'javascript', 'python']
+        language: ['cpp']
+        # Learn more...
+        # https://docs.github.com/en/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#overriding-automatic-language-detection
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+      with:
+        # We must fetch at least the immediate parents so that if this is
+        # a pull request then we can checkout the head.
+        fetch-depth: 2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file. 
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    - name: Autobuild
+      working-directory: ./tests
+      run:  make exe
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2
@@ -37,3 +37,14 @@ depend
 # Others
 other/
 a*.dat
+config
+config.link
+*.log
+.vscode
+.vs
+tmp-serial.*
+*~
+*.gcda
+*.gcno
+*.gcov
+*.synt
@@ -1,6 +1,6 @@
 BSD 2-Clause License

-Copyright (c) 2017-2018, Patrick Pelissier
+Copyright (c) 2017-2023, Patrick Pelissier
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
@@ -1,24 +1,47 @@
+# Copyright (c) 2017-2023, Patrick Pelissier
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# + Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# + Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
 # Environnement variable. To customize if needed.
 RM=rm -f
 MKDIR=mkdir -p
+RMDIR=rmdir
 INSTALL=install
 INSTALL_PROGRAM=${INSTALL}
 INSTALL_DATA=${INSTALL} -m 644

 # Installation directory
 PREFIX=/usr/local
+DESTDIR=

 # Package name & version.
-PACKAGE=m*lib-$(VERSION)
-VERSION=0.2.1
+PACKAGE=m_lib-$(VERSION)
+VERSION=0.7.1

 # Define the contain of the distribution tarball
-# TODO: Get theses lists from GIT itself.
-HEADER=m-algo.h m-array.h m-atomic.h m-bitset.h m-bptree.h m-buffer.h m-concurrent.h m-core.h m-deque.h m-dict.h m-genint.h m-i-list.h m-i-shared.h m-list.h m-mempool.h m-mutex.h m-prioqueue.h m-rbtree.h m-shared.h m-snapshot.h m-string.h m-tuple.h m-variant.h m-worker.h
+HEADER=m-algo.h m-array.h m-atomic.h m-bitset.h m-bptree.h m-buffer.h m-c-mempool.h m-concurrent.h m-core.h m-deque.h m-dict.h m-funcobj.h m-genint.h m-i-list.h m-i-shared.h m-list.h m-mempool.h m-thread.h m-mutex.h m-prioqueue.h m-rbtree.h m-serial-bin.h m-serial-json.h m-shared.h m-snapshot.h m-string.h m-tree.h m-try.h m-tuple.h m-variant.h m-worker.h
 DOC1=LICENSE README.md
-DOC2=doc/API.txt doc/Container.html  doc/Container.ods doc/DEV.md doc/ISSUES.org doc/depend.png doc/oplist.png
-EXAMPLE=example/ex-array01.c  example/ex-array04.c   example/ex-dict02.c  example/ex-grep01.c  example/ex-multi01.c  example/ex-rbtree01.c example/ex-array02.c  example/ex-buffer01.c  example/ex-dict03.c  example/ex-list01.c  example/ex-multi02.c  example/Makefile example/ex-array03.c  example/ex-dict01.c    example/ex-dict04.c  example/ex-mph.c     example/ex-multi03.c
-TEST=tests/coverage.h tests/test-malgo.c tests/test-mbptree.c tests/test-mdeque.c tests/test-milist.c    tests/test-mmutex.c      tests/test-mshared.c    tests/test-mtuple.c    tests/test-obj.h     tests/tgen-mdict.c    tests/tgen-openmp.c  tests/wip-mregister.c tests/dict.txt    tests/test-marray.c   tests/test-mbuffer.c  tests/test-mdict.c    tests/test-mlist.c     tests/test-mprioqueue.c  tests/test-msnapshot.c  tests/test-mvariant.c  tests/tgen-bitset.c  tests/tgen-mlist.c    tests/tgen-queue.c tests/Makefile    tests/test-mbitset.c  tests/test-mcore.c    tests/test-mgenint.c  tests/test-mmempool.c  tests/test-mrbtree.c     tests/test-mstring.c    tests/test-mworker.c   tests/tgen-marray.c  tests/tgen-mstring.c  tests/tgen-shared.c
+DOC2=doc/API.txt doc/Container.html doc/Container.ods doc/depend.png doc/DEV.md doc/ISSUES.org doc/oplist.odp doc/oplist.png
+EXAMPLE=example/ex11-algo01.c example/ex11-algo02.c example/ex11-json01.c example/ex11-section.c example/ex-algo02.c example/ex-algo03.c example/ex-algo04.c example/ex-array00.c example/ex-array01.c example/ex-array02.c example/ex-array03.c example/ex-array04.c example/ex-array05.c example/ex-bptree01.c example/ex-buffer01.c example/ex-dict01.c example/ex-dict02.c example/ex-dict03.c example/ex-dict04.c example/ex-grep01.c example/ex-list01.c example/ex-mph.c example/ex-multi01.c example/ex11-multi02.c example/ex-multi03.c example/ex-multi04.c example/ex-multi05.c example/ex-rbtree01.c example/ex11-algo02.json example/ex11-json01.json example/Makefile example/ex-defer01.c example/ex-string01.c example/ex-string02.c example/ex-astar.c example/ex-string03.c example/ex11-tstc.c example/ex-no-stdio.c example/ex11-count-lines.c example/ex11-json-net.c example/ex11-rbtree02.c
+TEST=tests/test-malgo.c tests/test-marray.c tests/test-mbitset.c tests/test-mbptree.c tests/test-mbuffer.c tests/test-mcmempool.c tests/test-mconcurrent.c tests/test-mcore.c tests/test-mdeque.c tests/test-mdict.c tests/test-mfuncobj.c tests/test-mgenint.c tests/test-milist.c tests/test-mlist.c tests/test-mmempool.c tests/test-mmutex.c tests/test-mprioqueue.c tests/test-mrbtree.c tests/test-mserial-bin.c tests/test-mserial-json.c tests/test-mshared.c tests/test-msnapshot.c tests/test-mstring.c tests/test-mtuple.c tests/test-mvariant.c tests/test-mworker.c tests/tgen-bitset.c tests/tgen-marray.c tests/tgen-mdict.c tests/tgen-mlist.c tests/tgen-mstring.c tests/tgen-openmp.c tests/tgen-queue.c tests/tgen-shared.c tests/tgen-mserial.c tests/Makefile tests/coverage.h tests/test-obj.h tests/dict.txt tests/fail-chain-oplist.c  tests/fail-incompatible.c  tests/fail-no-oplist.c tests/test-mishared.c tests/check-array.cpp tests/check-deque.cpp tests/check-dplist.cpp tests/check-list.cpp tests/check-rbtree.cpp tests/check-uset.cpp tests/check-generic.hpp tests/test-mtree.c tests/check-bptree-map.cpp tests/check-bptree-set.cpp tests/check-prioqueue.cpp tests/check-umap.cpp

 .PHONY: all test check doc clean distclean depend install uninstall dist

@@ -31,17 +54,22 @@ check:
 	cd tests && $(MAKE) check
 	cd example && $(MAKE) all

-html:	doc
-doc:	README.md doc/depend.png
+checkall:
+	cd tests && $(MAKE) checkall
+	cd example && $(MAKE) all
+
+html:	README.md
 	markdown < README.md > README.html

+doc:	html doc/depend.png
+
 clean:
 	cd tests && $(MAKE) clean
 	cd example && $(MAKE) clean
 	cd bench && $(MAKE) clean
 	$(RM) README.html depend.dot
-	$(RM) -r 'm*lib-$(VERSION)'
-	$(RM) 'm*lib-$(VERSION).tar.bz2'
+	$(RM) -r 'm_lib-$(VERSION)'
+	$(RM) 'm_lib-$(VERSION).tar.bz2'

 distclean: clean
 	cd tests && $(MAKE) distclean
@@ -54,7 +82,7 @@ doc/depend.png: $(HEADER)
 	dot -Tpng depend.dot -o doc/depend.png
 	optipng -o7 doc/depend.png

-dist: $(HEADER) $(DOC1) $(DOC2) $(EXAMPLE) $(TEST) Makefile clean
+dist: $(HEADER) $(DOC1) $(DOC2) $(EXAMPLE) $(TEST) Makefile clean versioncheck
 	$(MKDIR) '$(PACKAGE)'
 	$(MKDIR) '$(PACKAGE)/doc'
 	$(MKDIR) '$(PACKAGE)/tests'
@@ -69,9 +97,22 @@ dist: $(HEADER) $(DOC1) $(DOC2) $(EXAMPLE) $(TEST) Makefile clean
 distcheck: dist
 	cd '$(PACKAGE)' && make check

+versioncheck:
+	@if test "$(VERSION)." != `grep M_CORE_VERSION m-core.h |awk '{printf "%d.",$$3 } END {printf "\n"}'` ; then echo "ERROR: Version mismatch between Makefile & HEADERS" ; exit 2 ; fi
+	@for i in *.h ; do echo $(HEADER) | grep -q $$i ; if test $$? -ne 0 ; then echo "ERROR: Missing header $$i in Makefile" ; exit 3 ; fi ; done
+	@for i in doc/* ; do echo $(DOC2) | grep -q $$i ; if test $$? -ne 0 ; then echo "ERROR: Missing document $$i in Makefile" ; exit 4 ; fi ; done
+	@for i in tests/*.c tests/*.txt tests/*.h ; do echo $(TEST) | grep -q $$i ; if test $$? -ne 0 ; then echo "ERROR: Missing test $$i in Makefile" ; exit 5 ; fi ; done
+	@for i in example/*.c example/*.json ; do echo $(EXAMPLE) | grep -q $$i ; if test $$? -ne 0 ; then echo "ERROR: Missing example $$i in Makefile" ; exit 6 ; fi ; done
+	@for i in tests/*.cpp tests/*.hpp ; do echo $(TEST) | grep -q $$i ; if test $$? -ne 0 ; then echo "ERROR: Missing test $$i in Makefile" ; exit 7 ; fi ; done
+
 install:
-	$(MKDIR) $(DESTDIR)$(PREFIX)/include
-	$(INSTALL_DATA) $(HEADER) $(DESTDIR)$(PREFIX)/include
+	$(MKDIR) $(DESTDIR)$(PREFIX)/include/m-lib
+	$(INSTALL_DATA) $(HEADER) $(DESTDIR)$(PREFIX)/include/m-lib

 uninstall:
-	for i in $(HEADER) ; do $(RM) $(DESTDIR)$(PREFIX)/include/$$i ; done
+	for i in $(HEADER) ; do $(RM) $(DESTDIR)$(PREFIX)/include/m-lib/$$i ; done
+	$(RMDIR) $(DESTDIR)$(PREFIX)/include/m-lib/
+
+format:
+	cd example && $(MAKE) ex-string01.exe
+	for i in $(HEADER) ; do ./example/ex-string01.exe $$i > tmp.h && mv tmp.h $$i ; done
@@ -1,20 +1,48 @@
+# Copyright (c) 2017-2023, Patrick Pelissier
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# + Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# + Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
 CC=cc -std=c11
 CXX=c++ -std=c++11
 CFLAGS=-O2 -march=native -Wall
+XCFLAGS=
 CPPFLAGS=-I..
 N=4
 BENCH_DEF=
+RM=rm -rf

-.PHONY: all container queue mempool string plain bench-mlib bench-mlib-mempool bench-stl bench-qt bench-glib bench-klib bench-libdynamic bench-sparsepp bench-collectionc bench-tommyds bench-flathashmap bench-hopscotchmap bench-mlib-thread bench-liblfds bench-concurrentqueue bench-boost bench-mempool bench-string bench-plain
+.PHONY: all pgo container queue mempool string plain bench-mlib bench-mlib-mempool bench-stl bench-qt bench-glib bench-klib bench-libdynamic bench-sparsepp bench-collectionc bench-tommyds bench-flathashmap bench-emilib bench-emhash bench-hopscotchmap bench-mlib-thread bench-liblfds bench-concurrentqueue bench-boost bench-mempool bench-string bench-plain bench-rigtorp-mpmc-queue bench-cmc

 all: container queue mempool string plain

+pgo:
+	$(MAKE) all XCFLAGS="-fprofile-generate=pgo"
+	$(MAKE) all XCFLAGS="-fprofile-use=pgo"
+
 #########################################################################

-container: bench-mlib bench-mlib-mempool bench-stl bench-qt bench-glib bench-klib bench-libdynamic bench-sparsepp bench-collectionc bench-tommyds bench-flathashmap bench-hopscotchmap
+container: bench-mlib bench-mlib-mempool bench-stl bench-qt bench-glib bench-klib bench-libdynamic bench-cmc bench-sparsepp bench-densehashmap bench-collectionc bench-tommyds bench-flathashmap bench-emilib bench-emhash bench-hopscotchmap bench-uthash bench-qlibc bench-libsrt bench-nedtries bench-rigtorp-hashmap bench-ctl bench-stc bench-pottery bench-CC
 	@echo "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"

-queue: bench-mlib-thread bench-liblfds bench-concurrentqueue bench-boost
+queue: bench-mlib-thread bench-liblfds bench-concurrentqueue bench-boost bench-rigtorp-mpmc-queue
 	@echo "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"

 mempool: bench-mempool
@@ -32,7 +60,7 @@ plain: bench-plain


 bench-mlib:
-	$(CC) $(CFLAGS) $(CPPFLAGS) -pthread bench-mlib.c -o bench-mlib.exe
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -pthread bench-mlib.c common.c -o bench-mlib.exe
 	@./bench-mlib.exe 10
 	@./bench-mlib.exe 11
 	@./bench-mlib.exe 20
@@ -41,12 +69,14 @@ bench-mlib:
 	@./bench-mlib.exe 40
 	@./bench-mlib.exe 41
 	@./bench-mlib.exe 42
+	@./bench-mlib.exe 46
+	@./bench-mlib.exe 47
 	@./bench-mlib.exe 43
 	@./bench-mlib.exe 50
 	@./bench-mlib.exe 51

 bench-mlib-mempool:
-	$(CC) $(CFLAGS) $(CPPFLAGS) bench-mlib.c -DUSE_MEMPOOL -pthread -o bench-mlib-mempool.exe
+	$(CC) $(CFLAGS) $(CPPFLAGS) bench-mlib.c common.c -DUSE_MEMPOOL -pthread -o bench-mlib-mempool.exe
 	@./bench-mlib-mempool.exe 10
 	@./bench-mlib-mempool.exe 11
 	@./bench-mlib-mempool.exe 20
@@ -55,27 +85,31 @@ bench-mlib-mempool:
 	@./bench-mlib-mempool.exe 40
 	@./bench-mlib-mempool.exe 41
 	@./bench-mlib-mempool.exe 42
+	@./bench-mlib-mempool.exe 46
+	@./bench-mlib-mempool.exe 47
 	@./bench-mlib-mempool.exe 43
 	@./bench-mlib-mempool.exe 50
 	@./bench-mlib-mempool.exe 51

 bench-mlib-thread:
-	$(CC) $(CFLAGS) $(CPPFLAGS) bench-mlib.c -DMULTI_THREAD_MEASURE -pthread -o bench-mlib-thread.exe
+	$(CC) $(CFLAGS) $(CPPFLAGS) bench-mlib.c common.c -DMULTI_THREAD_MEASURE -pthread -o bench-mlib-thread.exe
 	@./bench-mlib-thread.exe 60
 	@./bench-mlib-thread.exe 61
 	@./bench-mlib-thread.exe 62
 	@./bench-mlib-thread.exe 63
 	@./bench-mlib-thread.exe 64
 	@./bench-mlib-thread.exe 65
+	@./bench-mlib-thread.exe 66

 bench-stl:
-	$(CXX) $(CFLAGS) $(CPPFLAGS) bench-stl.cpp -o bench-stl.exe
+	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) bench-stl.cpp common.c -o bench-stl.exe
 	@./bench-stl.exe 10
 	@./bench-stl.exe 20
 	@./bench-stl.exe 30
 	@./bench-stl.exe 40
 	@./bench-stl.exe 41
 	@./bench-stl.exe 42
+	@./bench-stl.exe 46
 	@./bench-stl.exe 43
 	@./bench-stl.exe 50
 	@./bench-stl.exe 51
@@ -84,7 +118,7 @@ bench-stl:
 bench-qt:
 	@if test -n "$${QT}" ; then $(MAKE) bench-qt0 ; else echo "Nothing to be done for QT." ; fi
 bench-qt0:
-	$(CXX) $(CFLAGS) $(CPPFLAGS) -fPIC `PKG_CONFIG_PATH="$${QT}" pkg-config --libs --cflags Qt5Core` bench-qt.cpp -o bench-qt.exe
+	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -fPIC bench-qt.cpp common.c -o bench-qt.exe `PKG_CONFIG_PATH="$${QT}" pkg-config --libs --cflags Qt5Core`
 	@./bench-qt.exe 10
 	@./bench-qt.exe 20
 	@./bench-qt.exe 30
@@ -97,7 +131,7 @@ bench-qt0:
 bench-glib:
 	@if test -n "$${GLIB}" ; then $(MAKE) bench-glib0 ; else echo "Nothing to be done for GLIB." ; fi
 bench-glib0:
-	$(CC) $(CFLAGS) $(CPPFLAGS) bench-glib.c -o bench-glib.exe `PKG_CONFIG_PATH="$${GLIB}" pkg-config --libs --cflags glib-2.0`
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) bench-glib.c common.c -o bench-glib.exe `PKG_CONFIG_PATH="$${GLIB}" pkg-config --libs --cflags glib-2.0`
 	@./bench-glib.exe 10
 	@./bench-glib.exe 20
 	@./bench-glib.exe 30
@@ -110,7 +144,7 @@ bench-klib:
 	@if test -n "$${KLIB}" ; then $(MAKE) bench-klib0 ; else echo "Nothing to be done for KLIB." ; fi

 bench-klib0:
-	$(CC) $(CFLAGS) $(CPPFLAGS) -I $${KLIB} bench-klib.c -o bench-klib.exe
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I $${KLIB} bench-klib.c common.c -o bench-klib.exe
 	@./bench-klib.exe 10
 	@./bench-klib.exe 20
 	@./bench-klib.exe 30
@@ -118,25 +152,32 @@ bench-klib0:
 	@./bench-klib.exe 41
 	@./bench-klib.exe 50

-# LIBDYNAMIC shall point to the the directory containing the file libdynamic.pc
+# CMC shall point to the directory where the CMC main header is
+bench-cmc:
+	@if test -n "$${CMC}" ; then $(MAKE) bench-cmc0 ; else echo "Nothing to be done for CMC." ; fi
+
+bench-cmc0:
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I $${CMC} bench-cmc.c common.c -o bench-cmc.exe
+	@./bench-cmc.exe 20
+	@./bench-cmc.exe 30
+	@./bench-cmc.exe 40
+
+# LIBDYNAMIC shall point to the the source directory where the source is built
 bench-libdynamic:
 	@if test -n "$${LIBDYNAMIC}" ; then $(MAKE) bench-libdynamic0 ; else echo "Nothing to be done for LIBDYNAMIC." ; fi

 bench-libdynamic0:
-	$(CC) $(CFLAGS) $(CPPFLAGS) bench-libdynamic.c -o bench-libdynamic.exe `PKG_CONFIG_PATH="$${LIBDYNAMIC}" pkg-config --libs --cflags libdynamic` 
-	@./bench-libdynamic.exe 10
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) bench-libdynamic.c common.c -o bench-libdynamic.exe -I$${LIBDYNAMIC}/src $${LIBDYNAMIC}/.libs/libdynamic.a
 	@./bench-libdynamic.exe 20
-	@./bench-libdynamic.exe 30
 	@./bench-libdynamic.exe 40
 	@./bench-libdynamic.exe 41
-	@./bench-libdynamic.exe 50

 # SPARSEPP shall point to the directory where the headers are
 bench-sparsepp:
 	@if test -n "$${SPARSEPP}" ; then $(MAKE) bench-sparsepp0 ; else echo "Nothing to be done for SPARSEPP." ; fi

 bench-sparsepp0:
-	$(CXX) $(CFLAGS) $(CPPFLAGS) -I "$${SPARSEPP}"  -I "$${SPARSEPP}/.." bench-sparsepp.cpp -o bench-sparsepp.exe
+	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${SPARSEPP}"  -I "$${SPARSEPP}/.." bench-sparsepp.cpp common.c -o bench-sparsepp.exe
 	@./bench-sparsepp.exe 41
 	@./bench-sparsepp.exe 42
 	@./bench-sparsepp.exe 43
@@ -146,17 +187,17 @@ bench-densehashmap:
 	@if test -n "$${DENSEHASHMAP}" ; then $(MAKE) bench-densehashmap0 ; else echo "Nothing to be done Google DENSEHASHMAP." ; fi

 bench-densehashmap0:
-	$(CXX) $(CFLAGS) $(CPPFLAGS) -I "$${DENSEHASHMAP}"  -I "$${DENSEHASHMAP}/.." bench-densehashmap.cpp -o bench-densehashmap.exe
+	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${DENSEHASHMAP}"  -I "$${DENSEHASHMAP}/.." bench-densehashmap.cpp common.c -o bench-densehashmap.exe
 	@./bench-densehashmap.exe 41
 	@./bench-densehashmap.exe 42
 	@./bench-densehashmap.exe 43

-# COLLECTIONC shall point to the directory where the 'src' directory is.
+# COLLECTIONC shall point to the directory where it is installed
 bench-collectionc:
 	@if test -n "$${COLLECTIONC}" ; then $(MAKE) bench-collectionc0 ; else echo "Nothing to be done for COLLECTIONC." ; fi

 bench-collectionc0:
-	$(CC) $(CFLAGS) $(CPPFLAGS) -I "$${COLLECTIONC}/include" -L "$${COLLECTIONC}" -static bench-collectionc.c -lcollectc -o bench-collectionc.exe
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${COLLECTIONC}/include/collectc"  bench-collectionc.c common.c "$${COLLECTIONC}/lib/libcollectc.a" -o bench-collectionc.exe
 	@./bench-collectionc.exe 10
 	@./bench-collectionc.exe 20
 	@./bench-collectionc.exe 30
@@ -169,7 +210,7 @@ bench-tommyds:
 	@if test -n "$${TOMMYDS}" ; then $(MAKE) bench-tommyds0 ; else echo "Nothing to be done for TOMMYDS." ; fi

 bench-tommyds0:
-	$(CC) $(CFLAGS) $(CPPFLAGS) -I "$${TOMMYDS}" bench-tommyds.c $${TOMMYDS}/tommyds/tommyarray.c $${TOMMYDS}/tommyds/tommylist.c $${TOMMYDS}/tommyds/tommytree.c $${TOMMYDS}/tommyds/tommyhashlin.c -o bench-tommyds.exe
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${TOMMYDS}" bench-tommyds.c $${TOMMYDS}/tommyds/tommyarray.c $${TOMMYDS}/tommyds/tommylist.c $${TOMMYDS}/tommyds/tommytree.c $${TOMMYDS}/tommyds/tommyhashlin.c common.c -o bench-tommyds.exe
 	@./bench-tommyds.exe 10
 	@./bench-tommyds.exe 20
 	@./bench-tommyds.exe 30
@@ -181,17 +222,40 @@ bench-flathashmap:
 	@if test -n "$${FLATHASHMAP}" ; then $(MAKE) bench-flathashmap0 ; else echo "Nothing to be done for FLATHASHMAP." ; fi

 bench-flathashmap0:
-	$(CXX) -std=c++14 $(CFLAGS) $(CPPFLAGS) -I "$${FLATHASHMAP}" bench-flathashmap.cpp -o bench-flathashmap.exe
+	$(CXX) -std=c++14 $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${FLATHASHMAP}" bench-flathashmap.cpp common.c -o bench-flathashmap.exe
 	@./bench-flathashmap.exe 41
 	@./bench-flathashmap.exe 42
+	@./bench-flathashmap.exe 46
 	@./bench-flathashmap.exe 43

+# EMILIB shall point to the directory where the headers are
+bench-emilib:
+	@if test -n "$${EMILIB}" ; then $(MAKE) bench-emilib0 ; else echo "Nothing to be done for EMILIB." ; fi
+
+bench-emilib0:
+	$(CXX) -std=c++14 $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${EMILIB}" bench-emilib.cpp common.c -o bench-emilib.exe
+	@./bench-emilib.exe 41
+	@./bench-emilib.exe 42
+	@./bench-emilib.exe 46
+	@./bench-emilib.exe 43
+
+# EMHASh shall point to the directory where the headers are
+bench-emhash:
+	@if test -n "$${EMHASH}" ; then $(MAKE) bench-emhash0 ; else echo "Nothing to be done for EMHASH." ; fi
+
+bench-emhash0:
+	$(CXX) -std=c++14 $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${EMHASH}" bench-emhash.cpp common.c -o bench-emhash.exe
+	@./bench-emhash.exe 41
+	@./bench-emhash.exe 42
+	@./bench-emhash.exe 46
+	@./bench-emhash.exe 43
+
 # HOPSCOTCHMAP shall point to the directory where the source are
 bench-hopscotchmap:
 	@if test -n "$${HOPSCOTCHMAP}" ; then $(MAKE) bench-hopscotchmap0 ; else echo "Nothing to be done for HOPSCOTCHMAP." ; fi

 bench-hopscotchmap0:
-	$(CXX) $(CFLAGS) $(CPPFLAGS) -I "$${HOPSCOTCHMAP}" bench-hopscotchmap.cpp -o bench-hopscotchmap.exe
+	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${HOPSCOTCHMAP}/include/tsl" bench-hopscotchmap.cpp common.c -o bench-hopscotchmap.exe
 	@./bench-hopscotchmap.exe 41
 	@./bench-hopscotchmap.exe 42
 	@./bench-hopscotchmap.exe 43
@@ -201,12 +265,11 @@ bench-uthash:
 	@if test -n "$${UTHASH}" ; then $(MAKE) bench-uthash0 ; else echo "Nothing to be done for UTHASH." ; fi

 bench-uthash0:
-	$(CC) $(CFLAGS) $(CPPFLAGS) -I "$${UTHASH}" bench-uthash.c -o bench-uthash.exe
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${UTHASH}" bench-uthash.c common.c -o bench-uthash.exe
 	@./bench-uthash.exe 10
 	@./bench-uthash.exe 20
+	@./bench-uthash.exe 40
 	@./bench-uthash.exe 41
-	@./bench-uthash.exe 42
-	@./bench-uthash.exe 43
 	@./bench-uthash.exe 50

 # QLIBC shall point to the directory where the library is installed.
@@ -214,24 +277,18 @@ bench-qlibc:
 	@if test -n "$${QLIBC}" ; then $(MAKE) bench-qlibc0 ; else echo "Nothing to be done for QLIBC." ; fi

 bench-qlibc0:
-	$(CC) $(CFLAGS) $(CPPFLAGS) -I "$${QLIBC}/include" -L "$${QLIBC}/lib" -lqlibc -pthread bench-qlibc.c -o bench-qlibc.exe
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${QLIBC}/include" -L "$${QLIBC}/lib" -lqlibc -pthread bench-qlibc.c common.c -o bench-qlibc.exe
 	@LD_LIBRARY_PATH="$${QLIBC}/lib:$${LD_LIBRARY_PATH}" ./bench-qlibc.exe 10
 	@LD_LIBRARY_PATH="$${QLIBC}/lib:$${LD_LIBRARY_PATH}" ./bench-qlibc.exe 20
 	@LD_LIBRARY_PATH="$${QLIBC}/lib:$${LD_LIBRARY_PATH}" ./bench-qlibc.exe 30
-	@LD_LIBRARY_PATH="$${QLIBC}/lib:$${LD_LIBRARY_PATH}" ./bench-qlibc.exe 42
-	@LD_LIBRARY_PATH="$${QLIBC}/lib:$${LD_LIBRARY_PATH}" ./bench-qlibc.exe 41

-# LIBSRT shall point to the directory where the source are
+# LIBSRT shall point to the directory where it is installed
 bench-libsrt:
 	@if test -n "$${LIBSRT}" ; then $(MAKE) bench-libsrt0 ; else echo "Nothing to be done for LIBSRT." ; fi

 bench-libsrt0:
-	$(CC) $(CFLAGS) $(CPPFLAGS) -I "$${LIBSRT}/src" bench-libsrt.c -o bench-libsrt.exe $${LIBSRT}/libsrt.a 
-	@./bench-libsrt.exe 10
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${LIBSRT}/src" bench-libsrt.c common.c -o bench-libsrt.exe $${LIBSRT}/src/.libs/libsrt.a 
 	@./bench-libsrt.exe 20
-	@./bench-libsrt.exe 41
-	@./bench-libsrt.exe 42
-	@./bench-libsrt.exe 43
 	@./bench-libsrt.exe 50


@@ -240,7 +297,7 @@ bench-libsrt0:
 bench-liblfds:
 	@if test -n "$${LIBLFDS}" ; then $(MAKE) bench-liblfds0 ; else echo "Nothing to be done for LIBLFDS." ; fi
 bench-liblfds0:
-	$(CC) $(CFLAGS) $(CPPFLAGS) -I "$${LIBLFDS}/inc" -Wno-unknown-pragmas bench-liblfds.c -o bench-liblfds.exe $${LIBLFDS}/bin/liblfds711.a -lpthread
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${LIBLFDS}/inc" -Wno-unknown-pragmas bench-liblfds.c common.c -DMULTI_THREAD_MEASURE -o bench-liblfds.exe $${LIBLFDS}/bin/liblfds711.a -lpthread
 	@LD_LIBRARY_PATH="$${LIBLFDS}/bin:$${LD_LIBRARY_PATH}" ./bench-liblfds.exe 60


@@ -249,36 +306,118 @@ bench-liblfds0:
 bench-concurrentqueue:
 	@if test -n "$${CONCURRENTQUEUE}" ; then $(MAKE) bench-concurrentqueue0 ; else echo "Nothing to be done for CONCURRENTQUEUE." ; fi
 bench-concurrentqueue0:
-	$(CXX) $(CFLAGS) $(CPPFLAGS) -I "$${CONCURRENTQUEUE}/" bench-concurrentqueue.cpp -o bench-concurrentqueue.exe -lpthread
+	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${CONCURRENTQUEUE}/" bench-concurrentqueue.cpp common.c -DMULTI_THREAD_MEASURE  -o bench-concurrentqueue.exe -lpthread
 	@./bench-concurrentqueue.exe 60


 # XXHASH shall point to the source directory of xxhash
+# The library shall be built.
 bench-xxhash:
 	@if test -n "$${XXHASH}" ; then $(MAKE) bench-xxhash0 ; else echo "Nothing to be done for XXHASH." ; fi
 bench-xxhash0:
-	$(CC) $(CFLAGS) $(CPPFLAGS) -I "$${XXHASH}/" bench-xxhash.c "$${XXHASH}/libxxhash.a" -o bench-xxhash.exe
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${XXHASH}/" bench-xxhash.c common.c "$${XXHASH}/libxxhash.a" -o bench-xxhash.exe
 	@./bench-xxhash.exe 70

 # BOOST shall point to the header location.
 bench-boost:
 	@if test -n "$${BOOST}" ; then $(MAKE) bench-boost0 ; else echo "Nothing to be done for BOOST." ; fi
 bench-boost0:
-	$(CXX) $(CFLAGS) $(CPPFLAGS) -I "$${BOOST}" bench-boost.cpp -o bench-boost.exe -lpthread
+	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${BOOST}" bench-boost.cpp common.c -DMULTI_THREAD_MEASURE -o bench-boost.exe -lpthread
 	@./bench-boost.exe 60

 # NEDTRIES shall point to the header location.
 bench-nedtries:
 	@if test -n "$${NEDTRIES}" ; then $(MAKE) bench-nedtries0 ; else echo "Nothing to be done for NEDTRIES." ; fi
 bench-nedtries0:
-	$(CC) $(CFLAGS) $(CPPFLAGS) -I "$${NEDTRIES}" bench-nedtries.c -o bench-nedtries.exe
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${NEDTRIES}" bench-nedtries.c common.c -o bench-nedtries.exe
 	@./bench-nedtries.exe 40
 	@./bench-nedtries.exe 45

+# RIGTORP_HASHMAP shall point to the directory where the headers are
+bench-rigtorp-hashmap:
+	@if test -n "$${RIGTORP_HASHMAP}" ; then $(MAKE) bench-rigtorp-hashmap0 ; else echo "Nothing to be done for RIGTORP_HASHMAP." ; fi
+
+bench-rigtorp-hashmap0:
+	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${RIGTORP_HASHMAP}/include" bench-rigtorp-hashmap.cpp common.c -o bench-rigtorp-hashmap.exe
+	@./bench-rigtorp-hashmap.exe 42
+	@./bench-rigtorp-hashmap.exe 41
+	@./bench-rigtorp-hashmap.exe 43
+
+# RIGTORP_MPMC_QUEUE shall point to the directory where the headers are
+bench-rigtorp-mpmc-queue:
+	@if test -n "$${RIGTORP_MPMC_QUEUE}" ; then $(MAKE) bench-rigtorp-mpmc-queue0 ; else echo "Nothing to be done for RIGTORP_MPMC_QUEUE." ; fi
+bench-rigtorp-mpmc-queue0:
+	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${RIGTORP_MPMC_QUEUE}" bench-rigtorp-mpmcqueue.cpp common.c -DMULTI_THREAD_MEASURE -o bench-mpmcqueue.exe -lpthread
+	@./bench-mpmcqueue.exe 60
+
+# CTL shall point to the source directory (not where the headers are)
+bench-ctl:
+	@if test -n "$${CTL}" ; then $(MAKE) bench-ctl0 ; else echo "Nothing to be done for CTL." ; fi
+
+bench-ctl0:
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I $${CTL} bench-ctl.c common.c -o bench-ctl.exe
+	@./bench-ctl.exe 10
+	@./bench-ctl.exe 20
+	@./bench-ctl.exe 30
+	@./bench-ctl.exe 40
+	@./bench-ctl.exe 50
+
+# STC shall point to the source directory (not where the headers are)
+bench-stc:
+	@if test -n "$${STC}" ; then $(MAKE) bench-stc0 ; else echo "Nothing to be done for STC." ; fi
+
+bench-stc0:
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I $${STC}/include bench-stc.c common.c -o bench-stc.exe
+	@./bench-stc.exe 10
+	@./bench-stc.exe 20
+	@./bench-stc.exe 30
+	@./bench-stc.exe 40
+	@./bench-stc.exe 41
+	@./bench-stc.exe 50
+
+# POTTERY shall point to the source directory (not where the headers are)
+bench-pottery:
+	@if test -n "$${POTTERY}" ; then $(MAKE) bench-pottery0 ; else echo "Nothing to be done for POTTERY." ; fi
+
+bench-pottery0:
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -DPOTTERY_AVAILABLE=1 -I $${POTTERY}/include bench-pottery.c common.c -o bench-pottery.exe
+	@./bench-pottery.exe 10
+	@./bench-pottery.exe 20
+	@./bench-pottery.exe 30
+	@./bench-pottery.exe 40
+	@./bench-pottery.exe 41
+	@./bench-pottery.exe 50
+
+# CCLIB shall point to the source directory of CC (where the headers are)
+bench-CC:
+	@if test -n "$${CCLIB}" ; then $(MAKE) bench-CC0 ; else echo "Nothing to be done for CC." ; fi
+
+bench-CC0:
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I $${CCLIB}/ bench-CC.c common.c -o bench-CC.exe
+	@./bench-CC.exe 10
+	@./bench-CC.exe 20
+	@./bench-CC.exe 40
+	@./bench-CC.exe 41
+
+############################################################################
+
+bench-mlib-json: bench-mlib
+	@./bench-mlib.exe 110
+	@./bench-mlib.exe 111
+	@./bench-mlib.exe 112
+
+bench-rapidjson:
+	@if test -n "$${RAPIDJSON}" ; then $(MAKE) bench-rapidjson0 ; else echo "Nothing to be done for RAPIDJSON." ; fi
+bench-rapidjson0:
+	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -I "$${RAPIDJSON}/" bench-rapidjson.cpp common.c -o bench-rapidjson.exe
+	@./bench-rapidjson.exe 110
+	@./bench-rapidjson.exe 111
+	@./bench-rapidjson.exe 112
+
 ############################################################################

 bench-plain:
-	$(CC) $(CFLAGS) $(CPPFLAGS) bench-plain-c.c -o bench-plain-c.exe
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) bench-plain-c.c -o bench-plain-c.exe
 	@./bench-plain-c.exe

 ############################################################################
@@ -286,13 +425,13 @@ bench-plain:
 bench-mempool:
 	@if test -n "$${BOOST}" ; then if test -n "$${GLIB}" ; then make bench-mempool0 BENCH_DEF="-DUSE_BOOST -DUSE_GLIB `pkg-config --libs --cflags glib-2.0` -lboost_system"  ; else make bench-mempool0 BENCH_DEF="-DUSE_BOOST -lboost_system" ; fi ; else if test -n "$${GLIB}" ; then make bench-mempool0 BENCH_DEF="-DUSE_GLIB `pkg-config --libs --cflags glib-2.0`"  ; else make bench-mempool0 ; fi ; fi
 bench-mempool0:
-	$(CXX) $(CFLAGS) $(CPPFLAGS) pool.cc  $(BENCH_DEF) -o bench-mempool.exe
+	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) pool.cc  $(BENCH_DEF) -o bench-mempool.exe
 	@./bench-mempool.exe

 ############################################################################

 bench-maxdict:
-	$(CC) $(CFLAGS) $(CPPFLAGS) max-dict.c -o bench-max-dict.exe
+	$(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) max-dict.c -o bench-max-dict.exe
 	@./bench-max-dict.exe

 ############################################################################
@@ -300,27 +439,49 @@ bench-maxdict:
 # BSTRLIB shall point to the BSTRLIB sources
 # LIBSRT shall point to the LIBSRT sources
 bench-string:
-	@if test -n "$${BSTRLIB}" ; then $(MAKE) bench-string-with BENCH_DEF="-DBENCH_CAN_USE_BSTRLIB -I ${BSTRLIB} $${BSTRLIB}/obj/bstrlib.o $${BSTRLIB}/obj/bstraux.o $${BSTRLIB}/obj/bstrwrap.o" ; else $(MAKE) bench-string-with ; fi
+	@if test -n "$${BSTRLIB}" ; then $(MAKE) bench-string-step1 BENCH_DEF="-DBENCH_CAN_USE_BSTRLIB -I ${BSTRLIB} $${BSTRLIB}/obj/bstrlib.o $${BSTRLIB}/obj/bstraux.o $${BSTRLIB}/obj/bstrwrap.o" ; else $(MAKE) bench-string-step1 ; fi

-bench-string-with:
-	@if test -n "$${LIBSRT}" ; then $(MAKE) bench-string-with2 BENCH_DEF="$(BENCH_DEF) -DBENCH_CAN_USE_LIBSRT -I$${LIBSRT}/src $${LIBSRT}/libsrt.a" ; else $(MAKE) bench-string-with2 BENCH_DEF="$(BENCH_DEF)"; fi
+bench-string-step1:
+	@if test -n "$${LIBSRT}" ; then $(MAKE) bench-string-step2 BENCH_DEF="$(BENCH_DEF) -DBENCH_CAN_USE_LIBSRT -I$${LIBSRT}/src $${LIBSRT}/src/.libs/libsrt.a" ; else $(MAKE) bench-string-step2 BENCH_DEF="$(BENCH_DEF)"; fi

 #NOTE: Need to build by hand sds.o since it is not build by default and sds.c is not compatible with C++
-bench-string-with2:
-	@if test -n "$${SDS}" ; then $(MAKE) bench-string-with3 BENCH_DEF="$(BENCH_DEF) -fpermissive -DBENCH_CAN_USE_SDS -I$${SDS}/ $${SDS}/sds.o" ; else $(MAKE) bench-string-with3 BENCH_DEF="$(BENCH_DEF)"; fi
+bench-string-step2:
+	@if test -n "$${SDS}" ; then $(MAKE) bench-string-step4 BENCH_DEF="$(BENCH_DEF) -fpermissive -DBENCH_CAN_USE_SDS -I$${SDS}/ $${SDS}/sds.o" ; else $(MAKE) bench-string-step4 BENCH_DEF="$(BENCH_DEF)"; fi

-bench-string-with3:
-	@if test -n "$${RAPIDSTRING}" ; then $(MAKE) bench-string-exe BENCH_DEF="$(BENCH_DEF) -DBENCH_CAN_USE_RAPIDSTRING -I$${RAPIDSTRING}/ " ; else $(MAKE) bench-string-exe BENCH_DEF="$(BENCH_DEF)"; fi
+bench-string-step4:
+	@if test -n "$${GLIB}" ; then $(MAKE) bench-string-step5 BENCH_DEF="$(BENCH_DEF) -DBENCH_CAN_USE_GLIB $$(pkg-config --cflags --libs glib-2.0)" ; else $(MAKE) bench-string-step5 BENCH_DEF="$(BENCH_DEF)"; fi

-bench-string-exe:
-	$(CXX) $(CFLAGS) $(CPPFLAGS) -I "$${BSTRLIB}" -DBENCH_CAN_USE_STL -DBENCH_CAN_USE_MSTARLIB bench-string.cpp -o bench-string.exe $(BENCH_DEF)
+bench-string-step5:
+	@if test -n "$${POTTERY}" ; then $(MAKE) bench-string-step6 BENCH_DEF="$(BENCH_DEF) -DBENCH_CAN_USE_POTTERY -I$${POTTERY}/include -I$${POTTERY}/util/ $${POTTERY}/util/pottery/string/string.c" ; else $(MAKE) bench-string-step6 BENCH_DEF="$(BENCH_DEF)"; fi
+
+bench-string-step6:
+	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -DBENCH_CAN_USE_STL -DBENCH_CAN_USE_MSTARLIB bench-string.cpp common.c $(BENCH_DEF) -o bench-string.exe 
+	$(CXX) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -DBENCH_CAN_USE_STL -DBENCH_CAN_USE_MSTARLIB bench-string-2.cpp common.c $(BENCH_DEF) -o bench-string-2.exe 
 	@./bench-string.exe
+	@./bench-string-2.exe  2000000 0
+	@./bench-string-2.exe  2000000 1
+	@./bench-string-2.exe  2000000 2
+	@./bench-string-2.exe  2000000 4
+	@./bench-string-2.exe  2000000 5

+bench-string-pgo:
+	$(MAKE) bench-string XCFLAGS="-fprofile-generate=pgo"
+	$(MAKE) bench-string XCFLAGS="-fprofile-use=pgo"
+
+############################################################################
+
+bench-find-sort:
+	g++ bench-find-sort.cpp -O2 -march=native -std=c++11 -I.. -g common.c -o bench-find-sort.exe
+	./bench-find-sort.exe 10000000

 ############################################################################

 clean:
-	rm -f *.o bench-*.exe bench-*.s *~ massif.out.*
+	$(RM) *.o bench-*.exe
+	$(RM) bench-*.s *~ massif.out.*
+	$(RM) plot-*.dat
+	$(RM) pgo
+	$(RM) tmp-serial.*
 	cd nucleotide && $(MAKE) clean

 ############################################################################
@@ -0,0 +1,140 @@
+#define NDEBUG
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "common.h"
+
+#include "cc.h"
+
+/********************************************************************************************/
+
+static void test_array(size_t n)
+{
+  vec( unsigned int ) a1, a2;
+  init(&a1);
+  init(&a2);
+  
+  for(size_t i = 0; i < n; i++) {
+    push(&a1, rand_get() );
+    push(&a2, rand_get() );
+  }
+  unsigned int s = 0;
+  for(unsigned long i = 0; i < n; i++) {
+    s += *get(&a1, i ) * *get(&a2, i );
+  }
+  g_result = s;
+
+  cleanup(&a1);
+  cleanup(&a2);
+}
+
+/********************************************************************************************/
+
+static void test_list(size_t n)
+{
+  list( unsigned int ) a1, a2;
+  init(&a1);
+  init(&a2);
+  
+  for(size_t i = 0; i < n; i++) {
+    push(&a1, rand_get() );
+    push(&a2, rand_get() );
+  }
+  unsigned int s = 0;
+  for(unsigned *it1 = first( &a1 ), *it2 = first( &a2 ); it1 != end( &a1 ); it1 = next( &a1, it1 ), it2 = next(&a2, it2) ) {
+    s += *it1 * *it2;
+  }
+  g_result = s;
+
+  cleanup(&a1);
+  cleanup(&a2);
+}
+
+/********************************************************************************************/
+
+static void
+test_dict(size_t  n)
+{
+  map( unsigned long, unsigned long ) dict;
+  init(&dict);
+  
+  for (size_t i = 0; i < n; i++) {
+    unsigned long value = rand_get();
+    unsigned long key = rand_get();
+    insert(&dict, key, value);
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    unsigned long key = rand_get();
+    const unsigned long *val = get(&dict, key);
+    if (val != NULL)
+      s += *val;
+  }
+  g_result = s;
+  
+  cleanup(&dict);
+}
+
+/********************************************************************************************/
+typedef struct {
+  char a[256];
+} char_array_t;
+static inline void char_init (char_array_t *a) { a->a[0] = 0; }
+static inline void char_set (char_array_t *a, const char_array_t b) { strcpy(a->a, b.a); }
+static inline bool char_equal_p (const char_array_t *a, const char_array_t *b) { return strcmp(a->a,b->a)==0; }
+static inline bool char_cmp (const char_array_t *a, const char_array_t *b) { return strcmp(a->a,b->a); }
+static inline void char_clear (char_array_t *a) { (void)a; }
+static inline size_t char_hash(const char_array_t *a) {
+  size_t hash = 0;
+  const char *s = a->a;
+  while (*s) hash = hash * 31421 + (*s++) + 6927;
+  return hash;
+}
+#define CC_DTOR char_array_t, { char_clear(&val); }
+#define CC_CMPR char_array_t, { return char_cmp(&val_1, &val_2); }
+#define CC_HASH char_array_t, { return char_hash(&val); }
+#include "cc.h"
+
+static void
+test_dict_big(size_t  n)
+{
+  map( char_array_t, char_array_t) dict;
+  init(&dict);
+  
+  for (size_t i = 0; i < n; i++) {
+    char_array_t s1, s2;
+    sprintf(s1.a, "%u", rand_get());
+    sprintf(s2.a, "%u", rand_get());
+    insert(&dict, s1, s2);
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    char_array_t s1;
+    sprintf(s1.a, "%u", rand_get());
+    const char_array_t *val = get(&dict, s1);
+    if (val != NULL)
+      s ++;
+  }
+  g_result = s;
+  
+  cleanup(&dict);
+}
+
+/********************************************************************************************/
+
+const config_func_t table[] = {
+  { 10,    "List", 10000000, 0, test_list, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 40,    "dict", 1000000, 0, test_dict, 0},
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+};
+
+int main(int argc, const char *argv[])
+{
+  test("CC", numberof(table), table, argc, argv);
+  exit(0);
+}
@@ -6,11 +6,8 @@

 #include <boost/lockfree/queue.hpp>

-#include "m-mutex.h"
-#define MULTI_THREAD_MEASURE
 #include "common.h"

-
 /********************************************************************************************/
 boost::lockfree::queue<unsigned int, boost::lockfree::capacity<4*64>> g_buff;
 boost::lockfree::queue<unsigned long long, boost::lockfree::capacity<4*64>> g_final;
@@ -51,7 +48,7 @@ static void prod(void *arg)
  }
 }

-static void test_buffer(size_t n)
+static void test_queue(size_t n)
 {
  const int cpu_count   = get_cpu_count();
  const int prod_count  = cpu_count/2;
@@ -88,11 +85,12 @@ static void test_buffer(size_t n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 60,    "Queue MPMC", 1000000, 0, test_queue, 0}
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 60)
-    test_function("Buffer time", 1000000, test_buffer);
+  test("BOOST-LOCKFREE", numberof(table), table, argc, argv);
  exit(0);
 }
-
@@ -0,0 +1,204 @@
+#define NDEBUG
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "macro_collections.h"
+
+#include "common.h"
+
+/********************************************************************************************/
+
+// CMC list are dynamic array
+#define MY_LIST_PARAMS (list_uint, list_uint_s, , , unsigned int)
+C_MACRO_COLLECTIONS_EXTENDED(CMC, LIST, MY_LIST_PARAMS, (STR))
+
+struct list_uint_s_fval list_fval = { .cmp = NULL,
+				      .cpy = NULL,
+				      .str = NULL,
+				      .free = NULL,
+				      .hash = NULL,
+				      .pri = NULL };
+
+static void test_array(size_t n)
+{
+  struct list_uint_s *a1 = list_uint_new(1, &list_fval);
+  struct list_uint_s *a2 = list_uint_new(1, &list_fval);
+  
+  for(size_t i = 0; i < n; i++) {
+    list_uint_push_back(a1, rand_get() );
+    list_uint_push_back(a2, rand_get() );
+  }
+  
+  unsigned int s = 0;
+  for(unsigned long i = 0; i < n; i++) {
+    s += list_uint_get(a1, i ) * list_uint_get(a2, i );
+  }
+  g_result = s;
+  
+  list_uint_free(a1);
+  list_uint_free(a2);
+}
+
+/********************************************************************************************/
+
+#define my_cmp(a,b) ( (a) < (b) ? -1 : (a) > (b) )
+
+#define MY_TMAP_PARAMS (tree_ulong, tree_ulong_s, , unsigned long, bool)
+C_MACRO_COLLECTIONS_EXTENDED(CMC, TREEMAP, MY_TMAP_PARAMS, (STR))
+
+int cmp_ulong(unsigned long a, unsigned long b) { return my_cmp(a,b); }
+
+struct tree_ulong_s_fkey tree_fkey = { .cmp = cmp_ulong,
+				       .cpy = NULL,
+				       .str = NULL,
+				       .free = NULL,
+				       .hash = NULL,
+				       .pri = NULL };
+
+struct tree_ulong_s_fval tree_fval = { .cmp = NULL,
+				       .cpy = NULL,
+				       .str = NULL,
+				       .free = NULL,
+				       .hash = NULL,
+				       .pri = NULL };
+
+static void test_rbtree(size_t n)
+{
+  struct tree_ulong_s *tree;
+  tree = tree_ulong_new(&tree_fkey, &tree_fval);
+
+  for (size_t i = 0; i < n; i++) {
+    unsigned long j = rand_get();
+    tree_ulong_insert(tree, j, true);
+  }
+    
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    unsigned long j = rand_get();
+    if (tree_ulong_get_ref(tree, j) != 0)
+      s+= j;
+  }
+  g_result = s;
+  tree_ulong_free(tree);
+}
+
+/********************************************************************************************/
+#define hash_func(a) kh_int64_hash_func(a)
+size_t hash_ulong(unsigned long a)
+{
+  return ( (a) >> 33 ) ^ (a) ^ ((a) << 11);
+}
+
+#define MY_DICT_PARAMS (hmap, hmap_s, , unsigned long, unsigned long)
+C_MACRO_COLLECTIONS_EXTENDED(CMC, HASHMAP, MY_DICT_PARAMS, (STR))
+
+struct hmap_s_fkey hmap_fkey = { .cmp = cmp_ulong,
+				 .cpy = NULL,
+				 .str = NULL,
+				 .free = NULL,
+				 .hash = hash_ulong,
+				 .pri = NULL };
+
+struct hmap_s_fval hmap_fval = { .cmp = NULL,
+				 .cpy = NULL,
+				 .str = NULL,
+				 .free = NULL,
+				 .hash = NULL,
+				 .pri = NULL };
+
+static void
+test_dict(size_t  n)
+{
+  struct hmap_s *dict = hmap_new(16, 0.7, &hmap_fkey, &hmap_fval);
+  
+  for (size_t i = 0; i < n; i++) {
+    hmap_insert(dict, rand_get(), rand_get());
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    unsigned long *val = hmap_get_ref(dict, rand_get());
+    if (val != 0)
+      s += *val;
+  }
+  g_result = s;
+  
+  hmap_free(dict);
+}
+
+/********************************************************************************************/
+
+#if 0 // Not working issue in using not integer types
+
+typedef struct {
+  char a[256];
+} char_array_t;
+static inline int char_cmp (const char_array_t a, const char_array_t b) { return strcmp(a.a,b.a); }
+static inline size_t char_hash(const char_array_t a) {
+  size_t hash = 0;
+  const char *s = a.a;
+  while (*s) hash = hash * 31421 + (*s++) + 6927;
+  return hash;
+}
+
+#define MY_DICTB_PARAMS (bhmap, bhmap_s, , char_array_t, char_array_t)
+C_MACRO_COLLECTIONS_EXTENDED(CMC, HASHMAP, MY_DICT_PARAMS, (STR))
+
+struct bhmap_s_fkey bhmap_fkey = { .cmp = char_cmp,
+				   .cpy = NULL,
+				   .str = NULL,
+				   .free = NULL,
+				   .hash = char_hash,
+				   .pri = NULL };
+
+struct bhmap_s_fval bhmap_fval = { .cmp = NULL,
+				 .cpy = NULL,
+				 .str = NULL,
+				 .free = NULL,
+				 .hash = NULL,
+				 .pri = NULL };
+
+static void
+test_dict_big(size_t  n)
+{
+  struct bhmap_s *dict = bhmap_new(16, 0.7, &bhmap_fkey, &bhmap_fval);
+  
+  for (size_t i = 0; i < n; i++) {
+    char_array_t s1, s2;
+    sprintf(s1.a, "%u", rand_get());
+    sprintf(s2.a, "%u", rand_get());
+    bhmap_insert(dict, s1, s2);
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    char_array_t s1;
+    sprintf(s1.a, "%u", rand_get() );
+    char_array_t *val = bhmap_get_ref(dict, s1);
+    if (val != 0)
+      s ++;
+  }
+  g_result = s;
+  
+  bhmap_free(dict);
+}
+#endif
+
+/********************************************************************************************/
+
+const config_func_t table[] = {
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 30,  "Rbtree", 1000000, 0, test_rbtree, 0},
+  { 40,    "dict", 1000000, 0, test_dict, 0},
+  //{ 41, "dictBig", 1000000, 0, test_dict_big, 0},
+};
+
+int main(int argc, const char *argv[])
+{
+  test("CMC", numberof(table), table, argc, argv);
+  exit(0);
+}
+
@@ -250,20 +250,17 @@ static void test_sort(size_t n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 10,    "List", 10000000, 0, test_list, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 30,  "Rbtree", 1000000, 0, test_rbtree, 0},
+  { 40,    "dict", 1000000, 0, test_dict, 0},
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 50,           "Sort",10000000, 0, test_sort, 0},
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 10)
-    test_function("List   time",10000000, test_list);
-  if (n == 20)
-    test_function("Array  time", 100000000, test_array);
-  if (n == 30)
-    test_function("Rbtree time", 1000000, test_rbtree);
-  if (n == 40)
-    test_function("Dict   time", 1000000, test_dict);
-  if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
-  if (n == 50)
-    test_function("Sort   time", 10000000, test_sort);
+  test("CollectionC", numberof(table), table, argc, argv);
  exit(0);
 }
@@ -6,11 +6,8 @@

 #include "concurrentqueue.h"

-#include "m-mutex.h"
-#define MULTI_THREAD_MEASURE
 #include "common.h"

-
 /********************************************************************************************/
 moodycamel::ConcurrentQueue<unsigned int> g_buff;
 moodycamel::ConcurrentQueue<unsigned long long> g_final;
@@ -51,7 +48,7 @@ static void prod(void *arg)
  }
 }

-static void test_buffer(size_t n)
+static void test_queue(size_t n)
 {
  const int cpu_count   = get_cpu_count();
  const int prod_count  = cpu_count/2;
@@ -88,11 +85,12 @@ static void test_buffer(size_t n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 60,    "Queue MPMC", 1000000, 0, test_queue, 0}
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 60)
-    test_function("Buffer time", 1000000, test_buffer);
+  test("CONCURRENT-QUEUE", numberof(table), table, argc, argv);
  exit(0);
 }
-
@@ -0,0 +1,183 @@
+#define NDEBUG
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "m-core.h"
+#include "common.h"
+
+typedef unsigned int uint;
+typedef unsigned long ulong;
+
+/********************************************************************************************/
+#define POD
+#define T uint
+#include "ctl/vector.h"
+
+static void test_array(size_t n)
+{
+  vec_uint a1 = vec_uint_init();
+  vec_uint a2 = vec_uint_init();
+  
+  for(size_t i = 0; i < n; i++) {
+    vec_uint_push_back(&a1, rand_get() );
+    vec_uint_push_back(&a2, rand_get() );
+  }
+  unsigned int s = 0;
+  for(unsigned long i = 0; i < n; i++) {
+    s += *vec_uint_at(&a1, i ) * *vec_uint_at(&a2, i );
+  }
+  g_result = s;
+
+  vec_uint_free(&a1);
+  vec_uint_free(&a2);
+}
+
+/********************************************************************************************/
+
+#define POD
+#define T uint
+#include "ctl/forward_list.h"
+
+static void test_list (size_t n)
+{
+  slist_uint a1 = slist_uint_init();
+  slist_uint a2 = slist_uint_init();
+
+  for(size_t i = 0; i < n; i++) {
+    slist_uint_push_front(&a1, rand_get());
+    slist_uint_push_front(&a2, rand_get());
+  }
+  unsigned int s = 0;
+  slist_uint_it it1 = slist_uint_begin(&a1);
+  slist_uint_it it2 = slist_uint_begin(&a2);
+  for( ; !slist_uint_it_done(&it1) ;
+       slist_uint_it_next(&it1), slist_uint_it_next(&it2)) {
+    s += *slist_uint_it_ref(&it1) * *slist_uint_it_ref(&it2);
+  }
+  g_result = s;
+
+  slist_uint_free(&a1);
+  slist_uint_free(&a2);
+}
+
+/********************************************************************************************/
+
+#define POD
+#define T ulong
+#include "ctl/set.h"
+
+static inline int
+int_cmp(ulong *a, ulong *b) {
+  return *a < *b;
+}
+
+static void test_rbtree(size_t n)
+{
+  set_ulong tree = set_ulong_init (int_cmp);
+  
+  for (size_t i = 0; i < n; i++) {
+    set_ulong_insert (&tree, rand_get() );
+  }
+    
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    unsigned long j = rand_get();
+    if (set_ulong_find_node(&tree, j) != NULL)
+      s+= j;
+  }
+  g_result = s;
+  set_ulong_free(&tree);
+}
+
+/********************************************************************************************/
+
+typedef struct {
+  unsigned long key;
+  unsigned long value;
+} pair_ulong;
+
+// Use of M*LIB hash function
+static inline size_t
+pair_ulong_hash(pair_ulong *a)
+{
+  return M_HASH_DEFAULT(a->key);
+}
+
+static inline int
+pair_ulong_equal(pair_ulong *a, pair_ulong *b)
+{
+  return a->key == b->key;
+}
+
+static inline void
+pair_ulong_free(pair_ulong *a) {
+  (void) a;
+}
+
+static inline pair_ulong
+pair_ulong_copy(pair_ulong *self) {
+  return (pair_ulong) { .key = self->key, .value = self->value };
+}
+
+#define T pair_ulong
+#include <ctl/unordered_map.h>
+
+static void
+test_dict(size_t  n)
+{
+  umap_pair_ulong dict = umap_pair_ulong_init(pair_ulong_hash, pair_ulong_equal);
+  
+  for (size_t i = 0; i < n; i++) {
+    unsigned long value = rand_get();
+    unsigned long key = rand_get();
+    umap_pair_ulong_insert(&dict, (pair_ulong) { key, value });
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    umap_pair_ulong_it it = umap_pair_ulong_find(&dict, (pair_ulong) { rand_get() , 0 } );
+    if (!umap_pair_ulong_it_done(&it) )
+      s += it.ref->value;
+  }
+  g_result = s;
+
+  umap_pair_ulong_free(&dict);
+}
+
+/********************************************************************************************/
+
+#define POD
+#define T float
+#include "ctl/vector.h"
+
+static void test_sort(size_t n)
+{
+  vec_float a1 = vec_float_init();
+
+  for(size_t i = 0; i < n; i++) {
+    vec_float_push_back(&a1, rand_get());
+  }
+  vec_float_sort(&a1);
+  g_result = *vec_float_at(&a1, 0);
+  vec_float_free(&a1);
+}
+
+/********************************************************************************************/
+
+const config_func_t table[] = {
+  { 10,    "List",  10000000, 0, test_list, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 30,  "Rbtree",   1000000, 0, test_rbtree, 0},
+  { 40,    "dict",   1000000, 0, test_dict, 0},
+  { 50,    "Sort",  10000000, 0, test_sort, 0},
+};
+
+int main(int argc, const char *argv[])
+{
+  test("CTL", numberof(table), table, argc, argv);
+  exit(0);
+}
+
@@ -131,14 +131,14 @@ test_dict_str(size_t  n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 42,"dict", 1000000, 0, test_dict2, 0},
+  { 43,    "DictStr", 1000000, 0, test_dict_str, 0}
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 42)
-    test_function("Dict(u)time", 1000000, test_dict2);
-  if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
-  if (n == 43)
-    test_function("DictS(u)  time", 1000000, test_dict_str);
+  test("DENSE-HASPMAP", numberof(table), table, argc, argv);
  exit(0);
 }
@@ -0,0 +1,138 @@
+#define NDEBUG
+
+#include <vector>
+#include <list>
+#include <iterator>
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <algorithm>
+#include <string>
+#include <sstream>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "hash_table7.hpp"
+
+using namespace emhash7;
+using namespace std;
+
+#include "common.h"
+
+/********************************************************************************************/
+
+static void
+test_dict2(size_t  n)
+{
+  HashMap<unsigned long, unsigned long> dict;
+  for (size_t i = 0; i < n; i++) {
+    dict[rand_get()] = rand_get();
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    HashMap<unsigned long, unsigned long>::iterator it = dict.find(rand_get());
+    if (it != dict.end())
+      s += it->second;
+  }
+  g_result = s;
+}
+
+static void
+test_dict2_linear(size_t  n)
+{
+  HashMap<unsigned long, unsigned long> dict;
+  for (size_t i = 0; i < n; i++) {
+    dict[i] = rand_get();
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    HashMap<unsigned long, unsigned long>::iterator it = dict.find(i);
+    if (it != dict.end())
+      s += it->second;
+  }
+  g_result = s;
+}
+
+/********************************************************************************************/
+struct char_array_s {
+  char a[256];
+  char_array_s () { a[0] = 0 ; }
+  char_array_s ( const char_array_s & other) { strcpy(a, other.a); }
+  bool operator==(const char_array_s &other) const { return strcmp(a, other.a) == 0; }
+};
+
+namespace std {
+  template <> struct hash<char_array_s> {
+    std::size_t operator()(const char_array_s &k) const {
+      size_t hash = 0;
+      const char *s = k.a;
+      while (*s) hash = hash * 31421 + (*s++) + 6927;
+      return hash;
+    };
+  };
+}
+
+static void
+test_dict_big(size_t  n)
+{
+  HashMap<char_array_s, char_array_s> dict;
+
+  for (size_t i = 0; i < n; i++) {
+    char_array_s s1, s2;
+    sprintf(s1.a, "%u", rand_get());
+    sprintf(s2.a, "%u", rand_get());
+    dict[s1] = s2;
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    char_array_s s1;
+    sprintf(s1.a, "%u", rand_get());
+    HashMap<char_array_s, char_array_s>::iterator it = dict.find(s1);
+    if (it != dict.end())
+      s ++;
+  }
+  g_result = s;
+}
+
+/********************************************************************************************/
+static void
+test_dict_str(size_t  n)
+{
+  HashMap<string, string> dict;
+
+  for (size_t i = 0; i < n; i++) {
+    string s1 = static_cast<ostringstream*>( &(ostringstream() << rand_get()) )->str();
+    string s2 = static_cast<ostringstream*>( &(ostringstream() << rand_get()) )->str();
+    dict[s1] = s2;
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    string s1 = static_cast<ostringstream*>( &(ostringstream() << rand_get()) )->str();
+    HashMap<string, string>::iterator it = dict.find(s1);
+    if (it != dict.end())
+      s ++;
+  }
+  g_result = s;
+}
+
+/********************************************************************************************/
+
+const config_func_t table[] = {
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 42,"dict", 1000000, 0, test_dict2, 0},
+  { 43,    "DictStr", 1000000, 0, test_dict_str, 0},
+  { 46,    "DictLinear", 1000000, 0, test_dict2_linear, 0}
+};
+
+int main(int argc, const char *argv[])
+{
+  test("EMHASH", numberof(table), table, argc, argv);
+  exit(0);
+}
@@ -0,0 +1,138 @@
+#define NDEBUG
+
+#include <vector>
+#include <list>
+#include <iterator>
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <algorithm>
+#include <string>
+#include <sstream>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "emilib/hash_map.hpp"
+
+using namespace emilib;
+using namespace std;
+
+#include "common.h"
+
+/********************************************************************************************/
+
+static void
+test_dict2(size_t  n)
+{
+  HashMap<unsigned long, unsigned long> dict;
+  for (size_t i = 0; i < n; i++) {
+    dict[rand_get()] = rand_get();
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    HashMap<unsigned long, unsigned long>::iterator it = dict.find(rand_get());
+    if (it != dict.end())
+      s += it->second;
+  }
+  g_result = s;
+}
+
+static void
+test_dict2_linear(size_t  n)
+{
+  HashMap<unsigned long, unsigned long> dict;
+  for (size_t i = 0; i < n; i++) {
+    dict[i] = rand_get();
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    HashMap<unsigned long, unsigned long>::iterator it = dict.find(i);
+    if (it != dict.end())
+      s += it->second;
+  }
+  g_result = s;
+}
+
+/********************************************************************************************/
+struct char_array_s {
+  char a[256];
+  char_array_s () { a[0] = 0 ; }
+  char_array_s ( const char_array_s & other) { strcpy(a, other.a); }
+  bool operator==(const char_array_s &other) const { return strcmp(a, other.a) == 0; }
+};
+
+namespace std {
+  template <> struct hash<char_array_s> {
+    std::size_t operator()(const char_array_s &k) const {
+      size_t hash = 0;
+      const char *s = k.a;
+      while (*s) hash = hash * 31421 + (*s++) + 6927;
+      return hash;
+    };
+  };
+}
+
+static void
+test_dict_big(size_t  n)
+{
+  HashMap<char_array_s, char_array_s> dict;
+
+  for (size_t i = 0; i < n; i++) {
+    char_array_s s1, s2;
+    sprintf(s1.a, "%u", rand_get());
+    sprintf(s2.a, "%u", rand_get());
+    dict[s1] = s2;
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    char_array_s s1;
+    sprintf(s1.a, "%u", rand_get());
+    HashMap<char_array_s, char_array_s>::iterator it = dict.find(s1);
+    if (it != dict.end())
+      s ++;
+  }
+  g_result = s;
+}
+
+/********************************************************************************************/
+static void
+test_dict_str(size_t  n)
+{
+  HashMap<string, string> dict;
+
+  for (size_t i = 0; i < n; i++) {
+    string s1 = static_cast<ostringstream*>( &(ostringstream() << rand_get()) )->str();
+    string s2 = static_cast<ostringstream*>( &(ostringstream() << rand_get()) )->str();
+    dict[s1] = s2;
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    string s1 = static_cast<ostringstream*>( &(ostringstream() << rand_get()) )->str();
+    HashMap<string, string>::iterator it = dict.find(s1);
+    if (it != dict.end())
+      s ++;
+  }
+  g_result = s;
+}
+
+/********************************************************************************************/
+
+const config_func_t table[] = {
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 42,"dict", 1000000, 0, test_dict2, 0},
+  { 43,    "DictStr", 1000000, 0, test_dict_str, 0},
+  { 46,    "DictLinear", 1000000, 0, test_dict2_linear, 0}
+};
+
+int main(int argc, const char *argv[])
+{
+  test("EMILIB", numberof(table), table, argc, argv);
+  exit(0);
+}
@@ -0,0 +1,101 @@
+// program to find longest contiguous subsequence
+// based on https://www.geeksforgeeks.org/longest-consecutive-subsequence/
+#include <iostream>
+#include <unordered_set>
+
+using namespace std; 
+  
+// Returns length of the longest contiguous subsequence 
+int cpp_find_longest(int arr[], int n) 
+{ 
+  unordered_set<int> S; 
+  int ans = 0; 
+  
+  // Hash all the array elements 
+  for (int i = 0; i < n; i++) 
+    S.insert(arr[i]); 
+  
+  // check each possible sequence from 
+  // the start then update optimal length 
+  for (int i = 0; i < n; i++) { 
+    // if current element is the starting 
+    // element of a sequence 
+    if (S.find(arr[i] - 1) == S.end()) { 
+      // Then check for next elements 
+      // in the sequence 
+      int j = arr[i] + 1;
+      while (S.find(j) != S.end()) 
+        j++; 
+      
+      // update  optimal length if 
+      // this length is more 
+      ans = max(ans, j - arr[i]); 
+    } 
+  } 
+  return ans; 
+} 
+
+#include "m-dict.h"
+
+static inline bool oor_equal_p(int a, unsigned char c) { return a == ((c == 0) ? INT_MIN : INT_MAX); }
+static inline void oor_set(int *a, unsigned char c) { *a = ((c == 0) ? INT_MIN : INT_MAX); }
+
+DICT_OASET_DEF(dict_int, int, M_OPEXTEND(M_DEFAULT_OPLIST, OOR_EQUAL(oor_equal_p), OOR_SET(oor_set M_IPTR)))
+
+// Returns length of the longest contiguous subsequence 
+int mlib_find_longest(int arr[], int n) 
+{ 
+  dict_int_t S;
+  int ans = 0; 
+
+  dict_int_init(S);
+  
+  // Hash all the array elements 
+  for (int i = 0; i < n; i++) 
+    dict_int_push(S, arr[i]);
+  
+  // check each possible sequence from 
+  // the start then update optimal length 
+  for (int i = 0; i < n; i++) { 
+    // if current element is the starting 
+    // element of a sequence
+    int *p = dict_int_get(S, arr[i]-1);
+    if (p == NULL) {
+      // Then check for next elements 
+      // in the sequence 
+      int j = arr[i] + 1; 
+      while (dict_int_get(S, j) != NULL)
+        j++; 
+      
+      // update  optimal length if 
+      // this length is more 
+      ans = M_MAX(ans, j - arr[i]); 
+    } 
+  }
+
+  dict_int_clear(S);
+  return ans; 
+} 
+
+#include "common.h"
+
+int main(int argc, const char *argv[]) 
+{
+  int n = argc == 1 ? 10000 : atoi(argv[1]);
+  int *arr = (int*) malloc(n * sizeof(int));
+  for(int i = 0; i < n; i++)
+    arr[i] = rand_get();
+  
+  unsigned long long t0 = cputime();
+  cout << "Length of the Longest contiguous subsequence is "
+       << cpp_find_longest(arr, n) << endl; 
+  
+  unsigned long long t1 = cputime();
+  
+  cout << "Length of the Longest contiguous subsequence is "
+       << mlib_find_longest(arr, n) << endl;
+  unsigned long long t2 = cputime();
+  
+  cout << "Time C++: " << (t1-t0) << " Time M*LIB: " << (t2-t1) << endl;
+  return 0; 
+}
@@ -42,6 +42,23 @@ test_dict2(size_t  n)
  g_result = s;
 }

+static void
+test_dict2_linear(size_t  n)
+{
+  flat_hash_map<unsigned long, unsigned long> dict;
+  for (size_t i = 0; i < n; i++) {
+    dict[i] = rand_get();
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    flat_hash_map<unsigned long, unsigned long>::iterator it = dict.find(i);
+    if (it != dict.end())
+      s += it->second;
+  }
+  g_result = s;
+}
+
 /********************************************************************************************/
 struct char_array_s {
  char a[256];
@@ -108,14 +125,15 @@ test_dict_str(size_t  n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 42,"dict", 1000000, 0, test_dict2, 0},
+  { 43,    "DictStr", 1000000, 0, test_dict_str, 0},
+  { 46,    "DictLinear", 1000000, 0, test_dict2_linear, 0}
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 42)
-    test_function("Dict(u)time", 1000000, test_dict2);
-  if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
-  if (n == 43)
-    test_function("DictS(u)  time", 1000000, test_dict_str);
+  test("FLAT-HASPMAP", numberof(table), table, argc, argv);
  exit(0);
 }
@@ -186,20 +186,17 @@ static void test_sort(size_t n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 10,    "List", 10000000, 0, test_list, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 30,  "Rbtree", 1000000, 0, test_rbtree, 0},
+  { 40,    "dict", 1000000, 0, test_dict, 0},
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 50,           "Sort",10000000, 0, test_sort, 0},
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 10)
-    test_function("List   time",10000000, test_list);
-  if (n == 20)
-    test_function("Array  time", 100000000, test_array);
-  if (n == 30)
-    test_function("Rbtree time", 1000000, test_rbtree);
-  if (n == 40)
-    test_function("Dict   time", 1000000, test_dict);
-  if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
-  if (n == 50)
-    test_function("Sort   time", 10000000, test_sort);
+  test("GLIB", numberof(table), table, argc, argv);
  exit(0);
 }
@@ -15,7 +15,7 @@
 #include <stdbool.h>
 #include <string.h>

-#include "src/hopscotch_map.h"
+#include "hopscotch_map.h"

 using namespace tsl;
 using namespace std;
@@ -109,14 +109,15 @@ test_dict_str(size_t  n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 42,"dict", 1000000, 0, test_dict2, 0},
+  { 43,    "DictStr", 1000000, 0, test_dict_str, 0}
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 42)
-    test_function("Dict(u)time", 1000000, test_dict2);
-  if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
-  if (n == 43)
-    test_function("DictS(u)  time", 1000000, test_dict_str);
+  test("HOPSCOTCHMAP", numberof(table), table, argc, argv);
  exit(0);
+
 }
@@ -185,21 +185,18 @@ static void test_sort(size_t n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 10,    "List", 10000000, 0, test_list, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 30,  "Rbtree", 1000000, 0, test_rbtree, 0},
+  { 40,    "dict", 1000000, 0, test_dict, 0},
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 50,           "Sort",10000000, 0, test_sort, 0},
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]): 0;
-  if (n == 10)
-    test_function("List   time",10000000, test_list);
-  if (n == 20)
-    test_function("Array  time", 100000000, test_array);
-  if (n == 30)
-    test_function("B-tree time", 1000000, test_rbtree);
-  if (n == 40)
-    test_function("DictOA time", 1000000, test_dict);
-  if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
-  if (n == 50)
-    test_function("Sort   time", 10000000, test_sort);
+  test("KLIB", numberof(table), table, argc, argv);
  exit(0);
 }

@@ -7,6 +7,9 @@
 #include <stdint.h>
 #include <unistd.h>

+// Needed due to compilation error in pool.h
+#include <pthread.h>
+
 #include "dynamic.h"

 #include "common.h"
@@ -45,6 +48,9 @@ static size_t hash_func (void *a)
 static int equal_func(void *a, void *b)
 {
  const unsigned long *pa = a;
+  if (b == NULL) {
+    return *pa == -1U;      
+  }
  const unsigned long *pb = b;
  return *pa == *pb;
 }
@@ -52,8 +58,12 @@ static int equal_func(void *a, void *b)
 static void set_func(void *a, void *b)
 {
  unsigned long *pa = a;
+  if (b == NULL) {
+    *pa = -1U;
+  } else {
    const unsigned long *pb = b;
    *pa = *pb;
+  }
 }

 typedef struct map_element map_element;
@@ -67,10 +77,10 @@ static void
 test_dict(size_t  n)
 {
  map dict;
-  map_construct(&dict, sizeof(map_element), (map_element[]) {{.key = -1}}, set_func);
+  map_construct(&dict, sizeof(map_element), set_func);

  for (size_t i = 0; i < n; i++) {
-    map_insert(&dict, (map_element[]) {{.key = rand_get(), .value = rand_get()}}, hash_func, equal_func, set_func, NULL);
+    map_insert(&dict, (map_element[]) {{.key = rand_get(), .value = rand_get()}}, hash_func, set_func, equal_func, NULL);
  }    
  rand_init();
  unsigned int s = 0;
@@ -90,6 +100,8 @@ typedef char char_array_t[256];
 static int char_equal (void *a, void *b)
 {
  const char_array_t *pa = (const char_array_t *)a;
+  if (b == NULL)
+    return strcmp(*pa, "") == 0;
  const char_array_t *pb = (const char_array_t *)b;
  return strcmp(*pa,*pb)==0;
 }
@@ -103,8 +115,12 @@ static size_t char_hash(void *a)
 static void char_set(void *a, void *b)
 {
  char_array_t *pa = (char_array_t *)a;
+  if (b == NULL) {
+    strcpy(*pa, "");
+  } else {
    const char_array_t *pb = (const char_array_t *)b;
    strcpy(*pa,*pb);
+  }
 }

 typedef struct big_map_element big_map_element;
@@ -118,16 +134,13 @@ static void
 test_dict_big(size_t  n)
 {
  map dict;
-  big_map_element empty;
-  strcpy(empty.key, "");
-  strcpy(empty.value, "");
-  map_construct(&dict, sizeof(big_map_element), &empty, char_set);
+  map_construct(&dict, sizeof(big_map_element), char_set);
  
  for (size_t i = 0; i < n; i++) {
    big_map_element el;
    sprintf(el.key, "%u", rand_get());
    sprintf(el.value, "%u", rand_get());
-    map_insert(&dict, &el, char_hash, char_equal, char_set, NULL);
+    map_insert(&dict, &el, char_hash, char_set, char_equal, NULL);
  }
  rand_init();
  unsigned int s = 0;
@@ -144,14 +157,14 @@ test_dict_big(size_t  n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 40,    "dict", 1000000, 0, test_dict, 0},
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 20)
-    test_function("Array  time", 100000000, test_array);
-  if (n == 40)
-    test_function("Dict   time", 1000000, test_dict);
-  if (n == 41)
-    test_function("Dict B time", 1000000, test_dict_big);
+  test("LIBDYNAMIC", numberof(table), table, argc, argv);
  exit(0);
 }
@@ -6,11 +6,8 @@

 #include "liblfds711.h"

-#include "m-mutex.h"
-#define MULTI_THREAD_MEASURE
 #include "common.h"

-
 /********************************************************************************************/

 struct lfds711_queue_bmm_state g_buff;
@@ -23,12 +20,9 @@ static void final(void *arg)
  unsigned long long j, s = 0;
  LFDS711_MISC_MAKE_VALID_ON_CURRENT_LOGICAL_CORE_INITS_COMPLETED_BEFORE_NOW_ON_ANY_OTHER_LOGICAL_CORE;
  for(int i = 0; i < n;i++) {
-    int rv;
-    do {
    void *p;
-      rv = lfds711_queue_bmm_dequeue(&g_final, &p, NULL);
+    while (0 == lfds711_queue_bmm_dequeue(&g_final, &p, NULL)) {  m_thread_yield(); }
    j = (uintptr_t)p;
-    } while (rv == 0);
    s += j;
  }
  g_result = s;
@@ -42,18 +36,12 @@ static void conso(void *arg)
  unsigned long long s = 0;
  LFDS711_MISC_MAKE_VALID_ON_CURRENT_LOGICAL_CORE_INITS_COMPLETED_BEFORE_NOW_ON_ANY_OTHER_LOGICAL_CORE;
  for(int i = 0; i < n;i++) {
-    int rv;
-    do {
    void *p;
-      rv = lfds711_queue_bmm_dequeue(&g_buff, &p, NULL);
+    while (0 == lfds711_queue_bmm_dequeue(&g_buff, &p, NULL)) {  m_thread_yield(); }
    j = (uintptr_t) p;
-    } while (rv == 0);
    s += j;
  }
-  int rv;
-  do {
-    rv = lfds711_queue_bmm_enqueue(&g_final, (void*)(uintptr_t)s, NULL);
-  } while (rv == 0); 
+  while (0 == lfds711_queue_bmm_enqueue(&g_final, (void*)(uintptr_t)s, NULL)) {  m_thread_yield(); }
 }

 static void prod(void *arg)
@@ -63,15 +51,12 @@ static void prod(void *arg)
  size_t r = n;
  LFDS711_MISC_MAKE_VALID_ON_CURRENT_LOGICAL_CORE_INITS_COMPLETED_BEFORE_NOW_ON_ANY_OTHER_LOGICAL_CORE;
  for(unsigned int i = 0; i < n;i++) {
-    int rv;
-    do {
-      rv = lfds711_queue_bmm_enqueue(&g_buff, (void*)(uintptr_t)r, NULL);
-    } while (rv == 0);
+    while (0 == lfds711_queue_bmm_enqueue(&g_buff, (void*)(uintptr_t)r, NULL)) {  m_thread_yield(); }
    r = r * 31421U + 6927U;
  }
 }

-static void test_buffer(size_t n)
+static void test_queue(size_t n)
 {
  const int cpu_count   = get_cpu_count();
  const int prod_count  = cpu_count/2;
@@ -120,11 +105,12 @@ static void test_buffer(size_t n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 60,    "Queue MPMC", 1000000, 0, test_queue, 0}
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 60)
-    test_function("Buffer time", 1000000, test_buffer);
+  test("LIBLFDS", numberof(table), table, argc, argv);
  exit(0);
 }
-
@@ -14,8 +14,8 @@

 static void test_array(size_t n)
 {
-  sv_t *a1 = sv_alloc ( sizeof (unsigned int), 16, NULL);
-  sv_t *a2 = sv_alloc ( sizeof (unsigned int), 16, NULL);
+  srt_vector *a1 = sv_alloc ( sizeof (unsigned int), 16, NULL);
+  srt_vector *a2 = sv_alloc ( sizeof (unsigned int), 16, NULL);

  for(size_t i = 0; i < n; i++) {
    unsigned int value = rand_get();
@@ -48,7 +48,7 @@ static int cmp_float (const void *a, const void *b)

 static void test_sort(size_t n)
 {
-  sv_t *a1 = sv_alloc(sizeof(float), 16, cmp_float);
+  srt_vector *a1 = sv_alloc(sizeof(float), 16, cmp_float);
  for(size_t i = 0; i < n; i++) {
    unsigned int value = rand_get();
    sv_push(&a1, &value );
@@ -60,13 +60,15 @@ static void test_sort(size_t n)

 /********************************************************************************************/

+
+const config_func_t table[] = {
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 50,    "sort", 10000000, 0, test_sort, 0}
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 20)
-    test_function("Array  time", 100000000, test_array);
-  if (n == 50)
-    test_function("Sort   time", 10000000, test_sort);
+  test("LIBSRT", numberof(table), table, argc, argv);
  exit(0);
 }

@@ -8,14 +8,18 @@
 #include "m-list.h"
 #include "m-rbtree.h"
 #include "m-bptree.h"
+#include "m-deque.h"
 #include "m-dict.h"
 #include "m-algo.h"
 #include "m-mempool.h"
 #include "m-string.h"
 #include "m-buffer.h"
-#include "m-mutex.h"
+#include "m-thread.h"
 #include "m-deque.h"
 #include "m-concurrent.h"
+#include "m-tuple.h"
+#include "m-serial-bin.h"
+#include "m-serial-json.h"

 #include "common.h"

@@ -40,6 +44,26 @@ static void test_array(size_t n)

 /********************************************************************************************/

+DEQUE_DEF(deque_uint, unsigned int)
+
+static void test_deque(size_t n)
+{
+  M_LET(a1, a2, DEQUE_OPLIST(deque_uint)) {
+    for(size_t i = 0; i < n; i++) {
+      deque_uint_push_back(a1, rand_get() );
+      deque_uint_push_back(a2, rand_get() );
+    }
+    unsigned int s = 0;
+    deque_uint_it_t it1, it2;
+    for(deque_uint_it(it1, a1), deque_uint_it(it2, a2) ; !deque_uint_end_p(it1) ; deque_uint_next(it1), deque_uint_next(it2)) {
+      s += *deque_uint_cref(it1 ) * *deque_uint_cref(it2 );
+    }
+    g_result = s;
+  }
+}
+
+/********************************************************************************************/
+
 // Two benched mode: with or without mempool
 #ifdef USE_MEMPOOL
 LIST_DEF(list_uint, unsigned int, (MEMPOOL( list_mpool), MEMPOOL_LINKAGE(static)))
@@ -220,14 +244,36 @@ test_dict_oa(size_t  n)
  }
 }

-/********************************************************************************************/
+static void
+test_dict_oa_linear(size_t  n)
+{
+  M_LET(dict, DICT_OPLIST(dict_oa_ulong)) {
+    for (size_t i = 0; i < n; i++) {
+      dict_oa_ulong_set_at(dict, i, rand_get() );
+    }
+    rand_init();
+    unsigned int s = 0;
+    for (size_t i = 0; i < n; i++) {
+      unsigned long *p = dict_oa_ulong_get(dict, i);
+      if (p)
+        s += *p;
+    }
+    g_result = s;
+  }
+}

-typedef char char_array_t[256];
+/********************************************************************************************/
+#ifndef CHAR_ARRAY_SIZE
+#define CHAR_ARRAY_SIZE 256
+#endif
+typedef char char_array_t[CHAR_ARRAY_SIZE];
 static void char_init (char_array_t a) { a[0] = 0; }
 static void char_set (char_array_t a, const char_array_t b) { strcpy(a, b); }
 static bool char_equal_p (const char_array_t a, const char_array_t b) { return strcmp(a,b)==0; }
 static size_t char_hash(const char_array_t a) { return m_core_hash (a, strlen(a)); }
-#define M_OPL_char_array_t() (INIT(char_init), INIT_SET(char_set), SET(char_set), CLEAR(char_init), HASH(char_hash), EQUAL(char_equal_p))
+static bool char_oor_equal_p(const char_array_t a, unsigned char n) { return a[0] == 1+n; }
+static void char_oor_set(char_array_t a, unsigned char n) { a[0] = 1+n; }
+#define M_OPL_char_array_t() (INIT(char_init), INIT_SET(char_set), SET(char_set), CLEAR(char_init), HASH(char_hash), EQUAL(char_equal_p), OOR_EQUAL(char_oor_equal_p), OOR_SET(char_oor_set))

 #ifdef USE_MEMPOOL
 DICT_STOREHASH_DEF2(dict_char, char_array_t, M_OPEXTEND(M_OPL_char_array_t(),MEMPOOL(dict_mpool2), MEMPOOL_LINKAGE(static)), char_array_t, M_OPL_char_array_t())
@@ -235,6 +281,7 @@ DICT_STOREHASH_DEF2(dict_char, char_array_t, M_OPEXTEND(M_OPL_char_array_t(),MEM
 DICT_STOREHASH_DEF2(dict_char, char_array_t, M_OPL_char_array_t(), char_array_t, M_OPL_char_array_t())
 #endif

+
 static void
 test_dict_big(size_t  n)
 {
@@ -264,6 +311,31 @@ test_dict_big(size_t  n)
 #endif
 }

+DICT_OA_DEF2(dict_oa_char, char_array_t, char_array_t)
+
+static void
+test_dict_oa_big(size_t  n)
+{
+  M_LET(dict, DICT_OPLIST(dict_oa_char)) {
+    for (size_t i = 0; i < n; i++) {
+      char_array_t s1, s2;
+      sprintf(s1, "%u", rand_get());
+      sprintf(s2, "%u", rand_get());
+      dict_oa_char_set_at(dict, s1, s2);
+    }
+    rand_init();
+    unsigned int s = 0;
+    for (size_t i = 0; i < n; i++) {
+      char_array_t s1;
+      sprintf(s1, "%u", rand_get());
+      char_array_t *p = dict_oa_char_get(dict, s1);
+      if (p)
+        s ++;
+    }
+    g_result = s;
+  }
+}
+
 /********************************************************************************************/

 #ifdef USE_MEMPOOL
@@ -441,7 +513,7 @@ static void conso_mpmc(void *arg)
  size_t n = *p_n;
  unsigned long long s = 0;
  for(int i = 0; i < n;i++) {
-    while (!queue_uint_pop(&j, g_buff_mpmc));
+    while (!queue_uint_pop(&j, g_buff_mpmc)) m_thread_yield();
    s += j;
  }
  while (!queue_ull_push(g_final_mpmc, s));
@@ -453,7 +525,7 @@ static void prod_mpmc(void *arg)
  size_t n = *p_n;
  size_t r = n;
  for(unsigned int i = 0; i < n;i++) {
-    while (!queue_uint_push(g_buff_mpmc, r ));
+    while (!queue_uint_push(g_buff_mpmc, r )) m_thread_yield();
    r = r * 31421U + 6927U;
  }
 }
@@ -526,7 +598,7 @@ static void conso_spsc(void *arg)
  size_t n = *p_n;
  unsigned long long s = 0;
  for(int i = 0; i < n;i++) {
-    while (!queue_single_uint_pop(&j, g_buff_spsc));
+    while (!queue_single_uint_pop(&j, g_buff_spsc)) m_thread_yield();
    s += j;
  }
  while (!queue_single_ull_push(g_final_spsc, s));
@@ -538,7 +610,7 @@ static void prod_spsc(void *arg)
  size_t n = *p_n;
  size_t r = n;
  for(unsigned int i = 0; i < n;i++) {
-    while (!queue_single_uint_push(g_buff_spsc, r ));
+    while (!queue_single_uint_push(g_buff_spsc, r )) m_thread_yield();
    r = r * 31421U + 6927U;
  }
 }
@@ -581,7 +653,96 @@ static void test_queue_single(size_t n)

 /********************************************************************************************/

-DEQUE_DEF(deque_uint, unsigned int)
+#define BULK_SIZE 20
+
+static void final_spsc_bulk(void *arg)
+{
+  size_t *p_n = arg;
+  size_t    n = *p_n;
+  unsigned long long j, s = 0;
+  for(int i = 0; i < n;i++) {
+    while (!queue_single_ull_pop(&j, g_final_spsc)) m_thread_yield();
+    s += j;
+  }
+  g_result = s;
+}
+
+static void conso_spsc_bulk(void *arg)
+{
+  size_t *p_n = arg;
+  size_t n = *p_n;
+  unsigned long long s = 0;
+  unsigned tab[BULK_SIZE];
+  for(int i = 0; i < n;i+= BULK_SIZE) {
+    unsigned k = queue_single_uint_pop_bulk(BULK_SIZE, tab, g_buff_spsc);
+    while (k != BULK_SIZE) {
+      m_thread_yield();
+      k += queue_single_uint_pop_bulk(BULK_SIZE-k, tab+k, g_buff_spsc);
+    }
+    for(k = 0; k < BULK_SIZE;k++)
+      s += tab[k];
+  }
+  while (!queue_single_ull_push(g_final_spsc, s));
+}
+
+static void prod_spsc_bulk(void *arg)
+{
+  size_t *p_n = arg;
+  size_t n = *p_n;
+  if ((n % BULK_SIZE) != 0) abort();
+  size_t r = n;
+  unsigned tab[BULK_SIZE];
+  for(unsigned int i = 0; i < n;i+= BULK_SIZE) {
+    for(unsigned k = 0; k < BULK_SIZE; k++) {
+      tab[k] = r;
+      r = r * 31421U + 6927U;
+    }
+    unsigned k = queue_single_uint_push_bulk(g_buff_spsc, BULK_SIZE, tab);
+    while (k != BULK_SIZE) {
+      m_thread_yield();
+      k += queue_single_uint_push_bulk(g_buff_spsc, BULK_SIZE-k, tab+k);
+    }
+  }
+}
+
+static void test_queue_single_bulk(size_t n)
+{
+  const int cpu_count   = 2;
+  const int prod_count  = cpu_count/2;
+  const int conso_count = cpu_count - prod_count;
+  // Init
+  queue_single_uint_init(g_buff_spsc, 64*cpu_count);
+  queue_single_ull_init (g_final_spsc, 64*cpu_count);
+
+  // Create thread
+  m_thread_t idx_p[prod_count];
+  m_thread_t idx_c[conso_count];
+  m_thread_t idx_final;
+  for(int i = 0; i < prod_count; i++) {
+    m_thread_create (idx_p[i], prod_spsc_bulk, &n);
+  }
+  for(int i = 0; i < conso_count; i++) {
+    m_thread_create (idx_c[i], conso_spsc_bulk, &n);
+  }
+  size_t n2 = conso_count;
+  m_thread_create(idx_final, final_spsc_bulk, &n2);
+
+  // Wait for jobs to be done.
+  for(int i = 0; i < prod_count; i++) {
+    m_thread_join(idx_p[i]);
+  }
+  for(int i = 0; i < conso_count; i++) {
+    m_thread_join(idx_c[i]);
+  }
+  m_thread_join(idx_final);
+
+  // Clear & quit
+  queue_single_ull_clear(g_final_spsc);
+  queue_single_uint_clear(g_buff_spsc);
+}
+
+/********************************************************************************************/
+
 CONCURRENT_DEF(cdeque_uint, deque_uint_t, M_OPEXTEND(DEQUE_OPLIST(deque_uint, M_DEFAULT_OPLIST), PUSH(deque_uint_push_front)))

 DEQUE_DEF(deque_ull, unsigned long long)
@@ -701,57 +862,225 @@ static void test_core_hash(size_t n)

 /********************************************************************************************/

+ARRAY_DEF(vector_string, string_t)
+
+vector_string_t vstring;
+vector_string_t vstring2;
+
+static void
+bench_vector_string_init(size_t n)
+{
+    vector_string_init(vstring);
+    for(size_t i = 0; i < n; i++)
+      {
+        M_LET( (s, "%zu", i), string_t) {
+            vector_string_push_back(vstring, s);
+        }
+    }
+    vector_string_init(vstring2);
+}
+
+static void
+bench_vector_string_init_big(size_t n)
+{
+    vector_string_init(vstring);
+    for(size_t i = 0; i < n; i++)
+    {
+        M_LET( (s, "%zu%zu%zu%zu%zu%zu", i, i, i, i, i, i), string_t) {
+            vector_string_push_back(vstring, s);
+        }
+    }
+    vector_string_init(vstring2);
+}
+
+static void
+bench_vector_string_bin_run(size_t n)
+{
+    if (vector_string_size(vstring) != n) {
+      fprintf(stderr, "ERROR: Size are different (%zu vs %zu)!\n", n, vector_string_size(vstring));
+      abort();
+    }
+
+    FILE *f = fopen("tmp-serial.dat", "wb");
+    if (!f) abort();
+    M_LET( (serial, f), m_serial_bin_write_t) {
+        vector_string_out_serial(serial, vstring);
+    }
+    fclose(f);
+    
+    f = fopen("tmp-serial.dat", "rb");
+    if (!f) abort();
+    M_LET( (serial, f), m_serial_bin_read_t) {
+        vector_string_in_serial(vstring2, serial);
+    }
+    fclose(f);
+
+    if (vector_string_size(vstring2) != n) {
+      fprintf(stderr, "ERROR: Size are different (%zu vs %zu)!\n", n, vector_string_size(vstring2));
+      abort();
+    }
+}
+
+static void
+bench_vector_string_json_run(size_t n)
+{
+    if (vector_string_size(vstring) != n) {
+      fprintf(stderr, "ERROR: Size are different (%zu vs %zu)!\n", n, vector_string_size(vstring));
+      abort();
+    }
+
+    FILE *f = fopen("tmp-serial.json", "wt");
+    if (!f) abort();
+    M_LET( (serial, f), m_serial_json_write_t) {
+        vector_string_out_serial(serial, vstring);
+    }
+    fclose(f);
+    
+    f = fopen("tmp-serial.json", "rt");
+    if (!f) abort();
+    M_LET( (serial, f), m_serial_json_read_t) {
+        vector_string_in_serial(vstring2, serial);
+    }
+    fclose(f);
+
+    if (vector_string_size(vstring2) != n) {
+      fprintf(stderr, "ERROR: Size are different (%zu vs %zu)!\n", n, vector_string_size(vstring2));
+      abort();
+    }
+}
+
+static void
+bench_vector_string_clear(void)
+{
+    if (!vector_string_equal_p(vstring, vstring2)) {
+      fprintf(stderr, "ERROR: Array are different after deserialization!\n");
+      abort();
+    }
+    vector_string_clear(vstring);
+    vector_string_clear(vstring2);
+}
+
+/********************************************************************************************/
+
+ARRAY_DEF(vector_ulong, unsigned long)
+
+vector_ulong_t vulong;
+vector_ulong_t vulong2;
+
+static void
+bench_vector_ulong_init(size_t n)
+{
+    vector_ulong_init(vulong);
+    for(size_t i = 0; i < n; i++)
+    {
+      vector_ulong_push_back(vulong, i*i);
+    }
+    vector_ulong_init(vulong2);
+}
+
+static void
+bench_vector_ulong_bin_run(size_t n)
+{
+    if (vector_ulong_size(vulong) != n) {
+      fprintf(stderr, "ERROR: Size are different!\n");
+      abort();
+    }
+
+    FILE *f = fopen("tmp-serial.dat", "wb");
+    if (!f) abort();
+    M_LET( (serial, f), m_serial_bin_write_t) {
+        vector_ulong_out_serial(serial, vulong);
+    }
+    fclose(f);
+    
+    f = fopen("tmp-serial.dat", "rb");
+    if (!f) abort();
+    M_LET( (serial, f), m_serial_bin_read_t) {
+        vector_ulong_in_serial(vulong2, serial);
+    }
+    fclose(f);
+
+    if (vector_ulong_size(vulong2) != n) {
+      fprintf(stderr, "ERROR: Size are different!\n");
+      abort();
+    }
+}
+
+static void
+bench_vector_ulong_json_run(size_t n)
+{
+    if (vector_ulong_size(vulong) != n) {
+      fprintf(stderr, "ERROR: Size are different!\n");
+      abort();
+    }
+
+    FILE *f = fopen("tmp-serial.json", "wt");
+    if (!f) abort();
+    M_LET( (serial, f), m_serial_json_write_t) {
+        vector_ulong_out_serial(serial, vulong);
+    }
+    fclose(f);
+    
+    f = fopen("tmp-serial.json", "rt");
+    if (!f) abort();
+    M_LET( (serial, f), m_serial_json_read_t) {
+        vector_ulong_in_serial(vulong2, serial);
+    }
+    fclose(f);
+
+    if (vector_ulong_size(vulong2) != n) {
+      fprintf(stderr, "ERROR: Size are different!\n");
+      abort();
+    }
+}
+
+static void
+bench_vector_ulong_clear(void)
+{
+    if (!vector_ulong_equal_p(vulong, vulong2)) {
+      fprintf(stderr, "ERROR: Array are different after deserialization!\n");
+      abort();
+    }
+    vector_ulong_clear(vulong);
+    vector_ulong_clear(vulong2);
+}
+
+/********************************************************************************************/
+
+const config_func_t table[] = {
+  { 10,    "List", 10000000, 0, test_list, 0},
+  { 11,  "DPList", 10000000, 0, test_dlist, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 21,   "Deque", 100000000, 0, test_deque, 0},
+  { 30,  "Rbtree", 1000000, 0, test_rbtree, 0},
+  { 31,  "B+tree", 1000000, 0, test_bptree, 0},
+  { 40,    "dict", 1000000, 0, test_dict, 0},
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 42,"dict(OA)", 1000000, 0, test_dict_oa, 0},
+  { 43,"DictStr", 1000000, 0, test_dict_str, 0},
+  { 46, "dictLinear(OA)", 1000000, 0, test_dict_oa_linear, 0},
+  { 47,    "dictBig(OA)", 1000000, 0, test_dict_oa_big, 0},
+  { 50,           "Sort",10000000, 0, test_sort, 0},
+  { 51,    "Stable Sort",10000000, 0, test_stable_sort, 0},
+  { 60,"Buffer",  1000000, 0, test_buffer, 0},
+  { 61,"Queue MPMC",  1000000, 0, test_queue, 0},
+  { 62,"Buffer(P=2)",  SIZE_LIMIT+1000000, 0, test_buffer, 0},
+  { 63,"Queue MPMC (P=2)",  SIZE_LIMIT+1000000, 0, test_queue, 0},
+  { 64,"Queue SPSC (P=2)",  1000000, 0, test_queue_single, 0},
+  { 65,"Queue Concurrent",  1000000, 0, test_queue_concurrent, 0},
+  { 66,"Queue SPSC(Bulk)",  1000000, 0, test_queue_single_bulk, 0},
+  { 70,"M_HASH",  100000000, test_hash_prepare, test_hash, test_hash_final},
+  { 71,"Core Hash", 100000000, test_hash_prepare, test_core_hash, test_hash_final},
+  {100,    "serial-bin STR", 10000000, bench_vector_string_init, bench_vector_string_bin_run, bench_vector_string_clear},
+  {101,    "serial-bin STR.big", 10000000, bench_vector_string_init_big, bench_vector_string_bin_run, bench_vector_string_clear},
+  {102,    "serial-bin INT", 10000000, bench_vector_ulong_init, bench_vector_ulong_bin_run, bench_vector_ulong_clear},
+  {110,    "serial-json STR", 10000000, bench_vector_string_init, bench_vector_string_json_run, bench_vector_string_clear},
+  {111,    "serial-json STR.big", 10000000, bench_vector_string_init_big, bench_vector_string_json_run, bench_vector_string_clear},
+  {112,    "serial-json INT", 10000000, bench_vector_ulong_init, bench_vector_ulong_json_run, bench_vector_ulong_clear}
+};

 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 10)
-    test_function("List   time",10000000, test_list);
-  if (n == 11)
-    test_function("DPList time",10000000, test_dlist);
-  if (n == 20)
-    test_function("Array  time", 100000000, test_array);
-  if (n == 30)
-    test_function("Rbtree time", 1000000, test_rbtree);
-  if (n == 31)
-    test_function("B+tree time", 1000000, test_bptree);
-  if (n == 40)
-    test_function("Dict   time", 1000000, test_dict);
-  if (n == 42)
-    test_function("DictOA time", 1000000, test_dict_oa);
-  if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
-  if (n == 43)
-    test_function("DictS  time", 1000000, test_dict_str);
-  if (n == 50)
-    test_function("Sort   time", 10000000, test_sort);
-  if (n == 51)
-    test_function("Stable Sort time", 10000000, test_stable_sort);
-  if (n == 60)
-    test_function("Buffer time", 1000000, test_buffer);
-  if (n == 61)
-    test_function("Queue MPMC time", 1000000, test_queue);
-  if (n == 62)
-    test_function("Buffer time (P2)", SIZE_LIMIT+1000000, test_buffer);
-  if (n == 63)
-    test_function("Queue MPMC time (P2)", SIZE_LIMIT+1000000, test_queue);
-  if (n == 64)
-    test_function("Queue SPSC time", 1000000, test_queue_single);
-  if (n == 65)
-    test_function("Queue CONCURRENT time", 1000000, test_queue_concurrent);
-  if (n == 70) {
-    n = (argc > 2) ? atoi(argv[2]) : 100000000;
-    test_hash_prepare(n);
-    test_function("M_HASH time", n, test_hash);
-    test_hash_final();
-  }
-  if (n == 71) {
-    n = (argc > 2) ? atoi(argv[2]) : 100000000;
-    test_hash_prepare(n);
-    test_function("CORE_HASH time", n, test_core_hash);
-    test_hash_final();
-  }
-  
+  test("M*LIB", numberof(table), table, argc, argv);
  exit(0);
 }
-
@@ -87,15 +87,13 @@ test_dict_noalloc(size_t  n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 40,    "dict", 1000000, 0, test_dict, 0},
+  { 45, "dict(noalloc)", 1000000, 0, test_dict_noalloc, 0}
+};

 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 40)
-    test_function("Dict   time", 1000000, test_dict);
-  if (n == 45)
-    test_function("Dict No Alloc time", 1000000, test_dict_noalloc);
-  
+  test("NEDTRIES", numberof(table), table, argc, argv);
  exit(0);
 }
-
@@ -32,7 +32,7 @@ struct Pixel
  unsigned char r, g, b;
 };

-ARRAY_DEF(array_pixel, struct Pixel, (INIT(M_NOTHING_DEFAULT)) )
+ARRAY_DEF(array_pixel, struct Pixel, (INIT(M_NOTHING_DEFAULT), INIT_SET(M_MEMCPY_DEFAULT) ))

 void UseMlib(void)
 {
@@ -0,0 +1,269 @@
+#define NDEBUG
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "common.h"
+
+/********************************************************************************************/
+
+#define POTTERY_VECTOR_PREFIX vec_uint
+#define POTTERY_VECTOR_VALUE_TYPE unsigned int
+#define POTTERY_VECTOR_LIFECYCLE_BY_VALUE 1
+#include "pottery/vector/pottery_vector_static.t.h"
+
+static void test_array(size_t n)
+{
+  vec_uint_t a1, a2;
+
+  vec_uint_init(&a1);
+  vec_uint_init(&a2);
+  
+  for(size_t i = 0; i < n; i++) {
+    vec_uint_insert_last(&a1, rand_get() );
+    vec_uint_insert_last(&a2, rand_get() );
+  }
+  unsigned int s = 0;
+  for(unsigned long i = 0; i < n; i++) {
+    s += *vec_uint_at(&a1, i ) * *vec_uint_at(&a2, i );
+  }
+  g_result = s;
+
+  vec_uint_destroy(&a1);
+  vec_uint_destroy(&a2);
+}
+
+/********************************************************************************************/
+
+typedef struct foo_s {
+  struct foo_s* next;
+  struct foo_s* previous;
+  int data;
+} foo_t;
+
+#define POTTERY_DOUBLY_LINKED_LIST_PREFIX foo_list
+#define POTTERY_DOUBLY_LINKED_LIST_VALUE_TYPE foo_t
+#include "pottery/doubly_linked_list/pottery_doubly_linked_list_static.t.h"
+
+static void test_list(size_t n)
+{
+  foo_list_t a1, a2;
+  foo_list_init(&a1);
+  foo_list_init(&a2);
+  for(size_t i = 0; i < n; i++) {
+    foo_t *tmp = malloc(sizeof (foo_t));
+    if (tmp == NULL) abort();
+    tmp->data = rand_get();
+    foo_list_link_last(&a1, tmp);
+
+    tmp = malloc(sizeof (foo_t));
+    if (tmp == NULL) abort();
+    tmp->data = rand_get();
+    foo_list_link_last(&a2, tmp);
+  }
+  unsigned int s = 0;
+  for(foo_t *it1 = foo_list_first(&a1), *it2 = foo_list_first(&a2) ;
+      foo_list_entry_exists(&a1, it1) ;
+      it1 = foo_list_next(&a1, it1), it2 = foo_list_next(&a2, it2)) {
+    s += it1->data * it2->data;
+  }
+  g_result = s;
+
+  for(foo_t *it1 = foo_list_first(&a1);
+      foo_list_entry_exists(&a1, it1) ;
+      ) {
+    foo_t *tmp = it1;
+    it1 = foo_list_next(&a1, it1);
+    free(tmp);
+  }
+
+  for(foo_t *it1 = foo_list_first(&a2);
+      foo_list_entry_exists(&a2, it1) ;
+      ) {
+    foo_t *tmp = it1;
+    it1 = foo_list_next(&a2, it1);
+    free(tmp);
+  }
+
+}
+
+/********************************************************************************************/
+
+// ERROR: it returns the wrong result.
+#define POTTERY_TREE_MAP_PREFIX set_ulong
+#define POTTERY_TREE_MAP_VALUE_TYPE unsigned long
+#define POTTERY_TREE_MAP_LIFECYCLE_MOVE_BY_VALUE 1
+#define POTTERY_TREE_MAP_COMPARE_THREE_WAY(a,b) ((a) < (b) ? -1 : (a) > (b))
+#define POTTERY_TREE_MAP_LIFECYCLE_DESTROY(a) (void) a
+#include "pottery/tree_map/pottery_tree_map_static.t.h"
+
+static void test_rbtree(size_t n)
+{
+  set_ulong_t tree;
+  set_ulong_init(&tree);
+  
+  for (size_t i = 0; i < n; i++) {
+    set_ulong_insert(&tree, rand_get() );
+  }
+    
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    unsigned long j = rand_get();
+    if (set_ulong_find(&tree, &j ) != NULL)
+      s += j;
+  }
+  g_result = s;
+  set_ulong_destroy(&tree);
+}
+
+
+/********************************************************************************************/
+
+#include "m-core.h"  // For M_HASH_DEFAULT
+typedef struct bar_s {
+  unsigned long key;
+  unsigned long value;
+} bar_t;
+
+#define POTTERY_OPEN_HASH_MAP_PREFIX map_ulong
+
+#define POTTERY_OPEN_HASH_MAP_VALUE_TYPE bar_t
+#define POTTERY_OPEN_HASH_MAP_KEY_TYPE unsigned long
+#define POTTERY_OPEN_HASH_MAP_REF_KEY(v) v->key
+#define POTTERY_OPEN_HASH_MAP_KEY_HASH(x) M_HASH_DEFAULT(x)
+#define POTTERY_OPEN_HASH_MAP_KEY_EQUAL(x, y) x == y
+#define POTTERY_OPEN_HASH_MAP_LIFECYCLE_MOVE(p,q) memcpy(p, q, sizeof (bar_t))
+
+#include "pottery/open_hash_map/pottery_open_hash_map_static.t.h"
+
+static void
+test_dict(size_t  n)
+{
+  map_ulong_t dict;
+  map_ulong_init(&dict);
+  
+  for (size_t i = 0; i < n; i++) {
+    unsigned long value = rand_get();
+    unsigned long key = rand_get();
+    bar_t * kyle = pottery_null;
+    map_ulong_emplace_key(&dict, key, &kyle, pottery_null);
+    kyle->key = key;
+    kyle->value = value;
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    bar_t *kyle = map_ulong_find(&dict, rand_get());
+    if (kyle != NULL)
+      s += kyle->value;
+  }
+  g_result = s;
+  
+  map_ulong_destroy(&dict);
+}
+
+/********************************************************************************************/
+
+typedef struct {
+  char a[256];
+} char_array_t;
+static inline void char_init (char_array_t *a) { a->a[0] = 0; }
+static inline void char_set (char_array_t *a, const char_array_t b) { strcpy(a->a, b.a); }
+static inline bool char_equal_p (const char_array_t a, const char_array_t b) { return strcmp(a.a,b.a)==0; }
+static inline void char_clear (char_array_t *a) { (void)a; }
+static inline size_t char_hash(const char_array_t *a) {
+  size_t hash = 0;
+  const char *s = a->a;
+  while (*s) hash = hash * 31421 + (*s++) + 6927;
+  return hash;
+}
+
+typedef struct bars_s {
+  char_array_t key;
+  char_array_t value;
+} bars_t;
+
+#define POTTERY_OPEN_HASH_MAP_PREFIX map_achar
+
+#define POTTERY_OPEN_HASH_MAP_VALUE_TYPE bars_t
+#define POTTERY_OPEN_HASH_MAP_KEY_TYPE char_array_t
+#define POTTERY_OPEN_HASH_MAP_REF_KEY(v) v->key
+#define POTTERY_OPEN_HASH_MAP_KEY_HASH(x) char_hash(&x)
+#define POTTERY_OPEN_HASH_MAP_KEY_EQUAL(x, y) char_equal_p(x, y)
+#define POTTERY_OPEN_HASH_MAP_LIFECYCLE_MOVE(p,q) memcpy(p, q, sizeof (bars_t))
+
+#include "pottery/open_hash_map/pottery_open_hash_map_static.t.h"
+
+static void
+test_dict_big(size_t  n)
+{
+  map_achar_t dict;
+  map_achar_init(&dict);
+
+  for (size_t i = 0; i < n; i++) {
+    char_array_t s1, s2;
+    sprintf(s1.a, "%u", rand_get());
+    sprintf(s2.a, "%u", rand_get());
+    bars_t * kyle = pottery_null;
+    map_achar_emplace_key(&dict, s1, &kyle, pottery_null);
+    char_set(&kyle->key, s1);
+    char_set(&kyle->value, s2);
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    char_array_t s1;
+    sprintf(s1.a, "%u", rand_get());
+    bars_t *kyle = map_achar_find(&dict, s1);
+    if (kyle != NULL)
+      s ++;
+  }
+  g_result = s;
+
+  map_achar_destroy(&dict);
+}
+
+/********************************************************************************************/
+
+#define POTTERY_VECTOR_PREFIX vec_float
+#define POTTERY_VECTOR_VALUE_TYPE float
+#define POTTERY_VECTOR_LIFECYCLE_BY_VALUE 1
+#include "pottery/vector/pottery_vector_static.t.h"
+
+#define POTTERY_INTRO_SORT_PREFIX sort_float
+#define POTTERY_INTRO_SORT_VALUE_TYPE float
+#define POTTERY_INTRO_SORT_LIFECYCLE_MOVE_BY_VALUE 1
+#define POTTERY_INTRO_SORT_COMPARE_THREE_WAY(x, y) ( *x < *y ? -1 : *x > *y)
+#include "pottery/intro_sort/pottery_intro_sort_static.t.h"
+
+static void test_sort(size_t n)
+{
+  vec_float_t a1;
+  vec_float_init(&a1);
+
+  for(size_t i = 0; i < n; i++) {
+    vec_float_insert_last(&a1, rand_get() );
+  }
+  sort_float(vec_float_at(&a1, 0), n);
+  g_result = *vec_float_at(&a1, 0);
+  vec_float_destroy(&a1);
+}
+
+/********************************************************************************************/
+
+const config_func_t table[] = {
+  { 10,    "List", 10000000, 0, test_list, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 30,  "Rbtree", 1000000, 0, test_rbtree, 0},
+  { 40,    "dict", 1000000, 0, test_dict, 0},
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 50,    "Sort",10000000, 0, test_sort, 0},
+};
+
+int main(int argc, const char *argv[])
+{
+  test("POTTERY", numberof(table), table, argc, argv);
+  exit(0);
+}
@@ -98,14 +98,16 @@ static void test_rbtree(size_t n)

 /* qlibc hash functions only accept a string as the key */

+/********************************************************************************************/
+
+const config_func_t table[] = {
+  { 10,    "List", 10000000, 0, test_list, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 30,  "Rbtree", 1000000, 0, test_rbtree, 0}
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 20)
-    test_function("Array  time", 100000000, test_array);
-  if (n == 10)
-    test_function("List   time",10000000, test_list);
-  if (n == 30)
-    test_function("Rbtree time", 1000000, test_rbtree);
+  test("QLIBC", numberof(table), table, argc, argv);
  exit(0);
 }
@@ -162,22 +162,18 @@ static void test_sort(size_t n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 10,    "List", 10000000, 0, test_list, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 30,  "Rbtree", 1000000, 0, test_rbtree, 0},
+  { 40,    "dict(m)", 1000000, 0, test_dict1, 0},
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 42,"dict(u)", 1000000, 0, test_dict2, 0},
+  { 50,           "Sort",10000000, 0, test_sort, 0}
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 10)
-    test_function("List   time",10000000, test_list);
-  if (n == 20)
-    test_function("Array  time", 100000000, test_array);
-  if (n == 30)
-     test_function("Rbtree time", 1000000, test_rbtree);
-  if (n == 40)
-    test_function("Dict(m)time", 1000000, test_dict1);
-  if (n == 42)
-    test_function("Dict(u)time", 1000000, test_dict2);
-  if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
-  if (n == 50)
-    test_function("Sort   time", 10000000, test_sort);
+  test("QT", numberof(table), table, argc, argv);
  exit(0);
 }
@@ -0,0 +1,185 @@
+#define NDEBUG
+#define RAPIDJSON_HAS_STDSTRING 1
+
+#include "rapidjson/reader.h"
+#include "rapidjson/document.h"
+#include "rapidjson/prettywriter.h"
+#include "rapidjson/filereadstream.h"
+#include "rapidjson/filewritestream.h"
+#include "rapidjson/encodedstream.h"
+#include "rapidjson/error/en.h"
+
+#include <stdio.h>
+#include <string>
+#include <vector>
+
+#include "common.h"
+
+using namespace std;
+
+/********************************************************************************************/
+
+vector<string> vstring;
+vector<string> vstring2;
+
+static void
+bench_vector_string_init(size_t n)
+{
+    for(size_t i = 0; i < n; i++)
+    {
+        char buff[100];
+        snprintf(buff, sizeof(buff), "%zu", i);
+        std::string s(buff);
+        vstring.push_back(s);
+    }
+}
+
+static void
+bench_vector_string_init_big(size_t n)
+{
+    for(size_t i = 0; i < n; i++)
+    {
+        char buff[100];
+        snprintf(buff, sizeof(buff), "%zu%zu%zu%zu%zu%zu", i, i, i, i, i, i);
+        std::string s(buff);
+        vstring.push_back(s);
+    }
+}
+
+static void
+bench_vector_string_json_run(size_t n)
+{
+    if (vstring.size() != n) {
+        printf("Size are different!\n");
+        abort();
+    }
+
+    FILE *f = fopen("tmp-serial.json", "wt");
+    if (!f) abort();
+    {
+        // Prepare writer and output stream.
+        char writeBuffer[65536];
+        typedef rapidjson::AutoUTFOutputStream<unsigned, rapidjson::FileWriteStream> OutputStream; 
+        rapidjson::FileWriteStream os(f, writeBuffer, sizeof(writeBuffer));
+        OutputStream eos(os, rapidjson::kUTF8, false); 
+        rapidjson::PrettyWriter<OutputStream, rapidjson::UTF8<>, rapidjson::AutoUTF<unsigned> > writer(eos);
+
+        writer.StartArray();
+        for(size_t i = 0; i < n; i++){
+            writer.String(vstring[i]);
+        }
+        writer.EndArray();
+    }
+    fclose(f);
+    
+    f = fopen("tmp-serial.json", "rt");
+    if (!f) abort();
+    {
+        char readBuffer[65536];
+        rapidjson::FileReadStream is(f, readBuffer, sizeof(readBuffer));
+        rapidjson::Document d;
+        d.ParseStream(is);
+        for(size_t i = 0; i < d.Size(); i++) {
+            rapidjson::Value& s = d[i];
+            vstring2.push_back(s.GetString());
+        }
+    }
+    fclose(f);
+
+    if (vstring2.size() != n) {
+        printf("Size are different!\n");
+        abort();
+    }
+}
+
+static void
+bench_vector_string_clear(void)
+{
+    if (vstring != vstring2) {
+        printf("Array are different!\n");
+        abort();
+    }
+}
+
+/********************************************************************************************/
+
+vector<unsigned long> vulong;
+vector<unsigned long> vulong2;
+
+static void
+bench_vector_ulong_init(size_t n)
+{
+    for(size_t i = 0; i < n; i++)
+    {
+      vulong.push_back(i*i);
+    }
+}
+
+static void
+bench_vector_ulong_json_run(size_t n)
+{
+    if (vulong.size() != n) {
+        printf("Size are different!\n");
+        abort();
+    }
+
+    FILE *f = fopen("tmp-serial.json", "wt");
+    if (!f) abort();
+    {
+        // Prepare writer and output stream.
+        char writeBuffer[65536];
+        typedef rapidjson::AutoUTFOutputStream<unsigned, rapidjson::FileWriteStream> OutputStream; 
+        rapidjson::FileWriteStream os(f, writeBuffer, sizeof(writeBuffer));
+        OutputStream eos(os, rapidjson::kUTF8, false); 
+        rapidjson::PrettyWriter<OutputStream, rapidjson::UTF8<>, rapidjson::AutoUTF<unsigned> > writer(eos);
+
+        writer.StartArray();
+        for(size_t i = 0; i < n; i++){
+            writer.Int64(vulong[i]);
+        }
+        writer.EndArray();
+    }
+    fclose(f);
+    
+    f = fopen("tmp-serial.json", "rt");
+    if (!f) abort();
+    {
+        char readBuffer[65536];
+        rapidjson::FileReadStream is(f, readBuffer, sizeof(readBuffer));
+        rapidjson::Document d;
+        d.ParseStream(is);
+        for(size_t i = 0; i < d.Size(); i++) {
+            rapidjson::Value& s = d[i];
+            vulong2.push_back(s.GetInt64());
+        }
+    }
+    fclose(f);
+
+    if (vulong2.size() != n) {
+        printf("Size are different!\n");
+        abort();
+    }
+}
+
+static void
+bench_vector_ulong_clear(void)
+{
+    if (vulong != vulong2) {
+        printf("Array are different!\n");
+        abort();
+    }
+}
+
+/********************************************************************************************/
+
+const config_func_t table[] = {
+  {110,    "serial-json STR", 10000000, bench_vector_string_init, bench_vector_string_json_run, bench_vector_string_clear},
+  {111,    "serial-json STR.big", 10000000, bench_vector_string_init_big, bench_vector_string_json_run, bench_vector_string_clear},
+  {112,    "serial-json INT", 10000000, bench_vector_ulong_init, bench_vector_ulong_json_run, bench_vector_ulong_clear}
+};
+
+int main(int argc, const char *argv[])
+{
+  test("RAPIDJSON", numberof(table), table, argc, argv);
+  exit(0);
+}
@@ -0,0 +1,159 @@
+#define NDEBUG
+
+#include <vector>
+#include <list>
+#include <iterator>
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <algorithm>
+#include <string>
+#include <sstream>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "rigtorp/HashMap.h"
+
+using namespace rigtorp;
+using namespace std;
+
+#include "common.h"
+
+/********************************************************************************************/
+
+// Hash for using unsigned long as lookup key
+struct UL_Hash {
+  size_t operator()(const unsigned long v) { return v * 7; }
+};
+
+// Equal comparison for using unsigned long as lookup key
+struct UL_Equal {
+  bool operator()(const unsigned long lhs, const unsigned long rhs) {
+    return lhs == rhs;
+  }
+};
+
+static void
+test_dict2(size_t  n)
+{
+  HashMap<unsigned long, unsigned long, UL_Hash, UL_Equal> dict(16, -1UL);
+
+  for (size_t i = 0; i < n; i++) {
+    dict[rand_get()] = rand_get();
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    HashMap<unsigned long, unsigned long, UL_Hash, UL_Equal>::iterator it = dict.find(rand_get());
+    if (it != dict.end())
+      s += it->second;
+  }
+  g_result = s;
+}
+
+/********************************************************************************************/
+
+
+struct char_array_s {
+  char a[256];
+  char_array_s () { a[0] = 0 ; }
+  char_array_s ( const char_array_s & other) { strcpy(a, other.a); }
+  bool operator==(const char_array_s &other) const { return strcmp(a, other.a) == 0; }
+};
+
+namespace std {
+  template <> struct hash<char_array_s> {
+    std::size_t operator()(const char_array_s &k) const {
+      size_t hash = 0;
+      const char *s = k.a;
+      while (*s) hash = hash * 31421 + (*s++) + 6927;
+      return hash;
+    };
+  };
+}
+
+struct BIG_Hash {
+  size_t operator()(const char_array_s v) { return hash<char_array_s>()(v); }
+};
+
+struct BIG_Equal {
+  bool operator()(const char_array_s lhs, const char_array_s rhs) {
+    return lhs == rhs;
+  }
+};
+
+static void
+test_dict_big(size_t  n)
+{
+  char_array_s empty;
+  HashMap<char_array_s, char_array_s, BIG_Hash, BIG_Equal> dict(16, empty);
+
+  for (size_t i = 0; i < n; i++) {
+    char_array_s s1, s2;
+    sprintf(s1.a, "%u", rand_get());
+    sprintf(s2.a, "%u", rand_get());
+    dict[s1] = s2;
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    char_array_s s1;
+    sprintf(s1.a, "%u", rand_get());
+    HashMap<char_array_s, char_array_s, BIG_Hash, BIG_Equal>::iterator it = dict.find(s1);
+    if (it != dict.end())
+      s ++;
+  }
+  g_result = s;
+}
+
+/********************************************************************************************/
+
+struct STR_Hash {
+  size_t operator()(const string v) { return hash<string>()(v); }
+};
+
+struct STR_Equal {
+  bool operator()(const string lhs, const string rhs) {
+    return lhs == rhs;
+  }
+};
+
+
+static void
+test_dict_str(size_t  n)
+{
+  string empty;
+  HashMap<string, string, STR_Hash, STR_Equal> dict(16, empty);
+
+  for (size_t i = 0; i < n; i++) {
+    string s1 = static_cast<ostringstream*>( &(ostringstream() << rand_get()) )->str();
+    string s2 = static_cast<ostringstream*>( &(ostringstream() << rand_get()) )->str();
+    dict[s1] = s2;
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    string s1 = static_cast<ostringstream*>( &(ostringstream() << rand_get()) )->str();
+    HashMap<string, string, STR_Hash, STR_Equal>::iterator it = dict.find(s1);
+    if (it != dict.end())
+      s ++;
+  }
+  g_result = s;
+}
+
+/********************************************************************************************/
+
+const config_func_t table[] = {
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 42,"dict", 1000000, 0, test_dict2, 0},
+  { 43,    "DictStr", 1000000, 0, test_dict_str, 0}
+};
+
+int main(int argc, const char *argv[])
+{
+  test("RIGTORP-HASHMAP", numberof(table), table, argc, argv);
+  exit(0);
+}
@@ -0,0 +1,96 @@
+#define NDEBUG
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#include <rigtorp/MPMCQueue.h>
+
+#include "common.h"
+
+/********************************************************************************************/
+rigtorp::MPMCQueue<unsigned int> g_buff(4*64);
+rigtorp::MPMCQueue<unsigned long long> g_final(4*64);
+
+static void final(void *arg)
+{
+  size_t *p_n = (size_t*) arg;
+  size_t    n = *p_n;
+  unsigned long long j, s = 0;
+  for(unsigned int i = 0; i < n;i++) {
+    g_final.pop(j);
+    s += j;
+  }
+  g_result = s;
+}
+
+static void conso(void *arg)
+{
+  unsigned int j;
+  size_t *p_n = (size_t*)arg;
+  size_t n = *p_n;
+  unsigned long long s = 0;
+  for(unsigned int i = 0; i < n;i++) {
+    g_buff.pop(j);
+    s += j;
+  }
+  g_final.push(s);
+}
+
+static void prod(void *arg)
+{
+  size_t *p_n = (size_t*)arg;
+  size_t n = *p_n;
+  size_t r = n;
+  for(unsigned int i = 0; i < n;i++) {
+    g_buff.push(r);
+    r = r * 31421U + 6927U;
+  }
+}
+
+static void test_queue(size_t n)
+{
+  const int cpu_count   = get_cpu_count();
+  const int prod_count  = cpu_count/2;
+  const int conso_count = cpu_count - prod_count;
+  if (cpu_count < 2) {
+    fprintf(stderr, "WARNING: Can not measure Buffer performance.\n");
+    return;
+  }
+  rand_get();
+  // Create thread
+  m_thread_t idx_p[prod_count];
+  m_thread_t idx_c[conso_count];
+  m_thread_t idx_final;
+  for(int i = 0; i < prod_count; i++) {
+    m_thread_create (idx_p[i], prod, &n);
+  }
+  for(int i = 0; i < conso_count; i++) {
+    m_thread_create (idx_c[i], conso, &n);
+  }
+  size_t n2 = conso_count;
+  m_thread_create(idx_final, final, &n2);
+
+  // Wait for jobs to be done.
+  for(int i = 0; i < prod_count; i++) {
+    m_thread_join(idx_p[i]);
+  }
+  for(int i = 0; i < conso_count; i++) {
+    m_thread_join(idx_c[i]);
+  }
+  m_thread_join(idx_final);
+
+}
+
+
+/********************************************************************************************/
+
+const config_func_t table[] = {
+  { 60,    "Queue MPMC", 1000000, 0, test_queue, 0}
+};
+
+int main(int argc, const char *argv[])
+{
+  test("RIGTORP-MPMC-QUEUE", numberof(table), table, argc, argv);
+  exit(0);
+}
@@ -109,14 +109,14 @@ test_dict_str(size_t  n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 42,"dict", 1000000, 0, test_dict2, 0},
+  { 43,    "DictStr", 1000000, 0, test_dict_str, 0}
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 42)
-    test_function("Dict(u)time", 1000000, test_dict2);
-  if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
-  if (n == 43)
-    test_function("DictS(u)  time", 1000000, test_dict_str);
+  test("SPARSEPP", numberof(table), table, argc, argv);
  exit(0);
 }
@@ -0,0 +1,193 @@
+#define NDEBUG
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "common.h"
+
+/********************************************************************************************/
+
+#define i_val unsigned int
+#define i_tag uint
+#include <stc/cvec.h>
+
+static void test_array(size_t n)
+{
+  cvec_uint a1 = cvec_uint_init(), a2 = cvec_uint_init();
+  
+  for(size_t i = 0; i < n; i++) {
+    cvec_uint_push_back(&a1, rand_get() );
+    cvec_uint_push_back(&a2, rand_get() );
+  }
+  unsigned int s = 0;
+  for(unsigned long i = 0; i < n; i++) {
+    s += *cvec_uint_at(&a1, i ) * *cvec_uint_at(&a2, i );
+  }
+  g_result = s;
+
+  cvec_uint_drop(&a1);
+  cvec_uint_drop(&a2);
+}
+
+/********************************************************************************************/
+#define i_val unsigned int
+#define i_tag uint
+#include <stc/clist.h>
+
+static void test_list(size_t n)
+{
+  clist_uint a1 = clist_uint_init(), a2 = clist_uint_init();
+  
+  for(size_t i = 0; i < n; i++) {
+    clist_uint_push_front(&a1, rand_get() );
+    clist_uint_push_front(&a2, rand_get() );
+  }
+  unsigned int s = 0;
+  for(clist_uint_iter it1 = clist_uint_begin(&a1), it2 = clist_uint_begin(&a2) ;
+      it1.ref != clist_uint_end(&a1).ref ;
+      clist_uint_next(&it1), clist_uint_next(&it2) ) {
+    s += *it1.ref * *it2.ref;
+  }
+  g_result = s;
+
+  clist_uint_drop(&a1);
+  clist_uint_drop(&a2);
+}
+
+/********************************************************************************************/
+
+#define i_tag ulong
+#define i_key unsigned long
+#include <stc/csset.h>
+
+static void test_rbtree(size_t n)
+{
+  csset_ulong tree = csset_ulong_init();
+  
+  for (size_t i = 0; i < n; i++) {
+    csset_ulong_insert(&tree, rand_get() );
+  }
+    
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    unsigned long j = rand_get();
+    if (csset_ulong_get(&tree, j ) != NULL)
+      s+= j;
+  }
+  g_result = s;
+  csset_ulong_drop(&tree);
+}
+
+/********************************************************************************************/
+
+#define i_tag ulong
+#define i_key unsigned long
+#define i_val unsigned long
+#include <stc/cmap.h>
+
+static void
+test_dict(size_t  n)
+{
+  cmap_ulong dict = cmap_ulong_init();
+  
+  for (size_t i = 0; i < n; i++) {
+    unsigned long value = rand_get();
+    unsigned long key = rand_get();
+    cmap_ulong_insert_or_assign(&dict, key, value);
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    const cmap_ulong_value*val = cmap_ulong_get(&dict, rand_get());
+    if (val != NULL)
+      s += val->second;
+  }
+  g_result = s;
+  
+  cmap_ulong_drop(&dict);
+}
+
+/********************************************************************************************/
+
+typedef struct {
+  char a[256];
+} char_array_t;
+static inline void char_init (char_array_t *a) { a->a[0] = 0; }
+static inline void char_set (char_array_t *a, const char_array_t b) { strcpy(a->a, b.a); }
+static inline bool char_equal_p (const char_array_t *a, const char_array_t *b) { return strcmp(a->a,b->a)==0; }
+static inline void char_clear (char_array_t *a) { (void)a; }
+static inline size_t char_hash(const char_array_t *a) {
+  size_t hash = 0;
+  const char *s = a->a;
+  while (*s) hash = hash * 31421 + (*s++) + 6927;
+  return hash;
+}
+
+#define i_tag       achar
+#define i_key       char_array_t
+#define i_val       char_array_t
+#define i_hash      char_hash
+#define i_eq        char_equal_p
+#include <stc/cmap.h>
+
+static void
+test_dict_big(size_t  n)
+{
+  cmap_achar dict = cmap_achar_init();
+
+  for (size_t i = 0; i < n; i++) {
+    char_array_t s1, s2;
+    sprintf(s1.a, "%u", rand_get());
+    sprintf(s2.a, "%u", rand_get());
+    cmap_achar_insert_or_assign(&dict, s1, s2);
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    char_array_t s1;
+    sprintf(s1.a, "%u", rand_get());
+    const cmap_achar_value*val = cmap_achar_get(&dict, s1);
+    if (val != NULL)
+      s ++;
+  }
+  g_result = s;
+
+  cmap_achar_drop(&dict);
+}
+
+/********************************************************************************************/
+
+#define i_val float
+#define i_tag float
+#include <stc/cvec.h>
+
+static void test_sort(size_t n)
+{
+  cvec_float a1 = cvec_float_init();
+
+  for(size_t i = 0; i < n; i++) {
+    cvec_float_push_back(&a1, rand_get() );
+  }
+  cvec_float_sort(&a1);
+  g_result = *cvec_float_at(&a1, 0);
+  cvec_float_drop(&a1);
+}
+
+/********************************************************************************************/
+
+const config_func_t table[] = {
+  { 10,    "List", 10000000, 0, test_list, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 30,  "Rbtree", 1000000, 0, test_rbtree, 0},
+  { 40,    "dict", 1000000, 0, test_dict, 0},
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 50,    "Sort",10000000, 0, test_sort, 0},
+};
+
+int main(int argc, const char *argv[])
+{
+  test("STC", numberof(table), table, argc, argv);
+  exit(0);
+}
@@ -1,6 +1,7 @@
 #define NDEBUG

 #include <vector>
+#include <deque>
 #include <list>
 #include <iterator>
 #include <map>
@@ -53,6 +54,23 @@ static void test_array(size_t n)

 /********************************************************************************************/

+static void test_deque(size_t n)
+{
+  deque<unsigned int> a1, a2;
+  for(size_t i = 0; i < n; i++) {
+    a1.push_back(rand_get() );
+    a2.push_back(rand_get() );
+  }
+  unsigned int s = 0;
+  for(auto it1 = a1.cbegin(), it2 = a2.cbegin();
+      it1 != a1.cend() ;it1++, it2++) {
+    s += *it1 * *it2;
+  }
+  g_result = s;
+}
+
+/********************************************************************************************/
+
 static void test_rbtree(size_t n)
 {
  set<unsigned long> tree;
@@ -110,6 +128,24 @@ test_dict2(size_t  n)
  g_result = s;
 }

+static void
+test_dict2_linear(size_t  n)
+{
+  unordered_map<unsigned long, unsigned long> dict;
+
+  for (size_t i = 0; i < n; i++) {
+    dict[i] = rand_get();
+  }
+  rand_init();
+  unsigned int s = 0;
+  for (size_t i = 0; i < n; i++) {
+    unordered_map<unsigned long, unsigned long>::iterator it = dict.find(i);
+    if (it != dict.end())
+      s += it->second;
+  }
+  g_result = s;
+}
+
 /********************************************************************************************/

 struct char_array_s {
@@ -220,28 +256,23 @@ static void test_stable_sort(size_t n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 10,    "List", 10000000, 0, test_list, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 21,   "Deque", 100000000, 0, test_deque, 0},
+  { 30,  "Rbtree", 1000000, 0, test_rbtree, 0},
+  { 40,    "dict(m)", 1000000, 0, test_dict1, 0},
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 42,"dict(u)", 1000000, 0, test_dict2, 0},
+  { 43,"DictStr(u)", 1000000, 0, test_dict_str, 0},
+  { 44,"DictStr(m)", 1000000, 0, test_dict_str2, 0},
+  { 46, "dictLinear(u)", 1000000, 0, test_dict2_linear, 0},
+  { 50,           "Sort",10000000, 0, test_sort, 0},
+  { 51,    "Stable Sort",10000000, 0, test_stable_sort, 0}
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 10)
-    test_function("List   time",10000000, test_list);
-  if (n == 20)
-    test_function("Array  time", 100000000, test_array);
-  if (n == 30)
-    test_function("Rbtree time", 1000000, test_rbtree);
-  if (n == 40)
-    test_function("Dict(m)time", 1000000, test_dict1);
-  if (n == 42)
-    test_function("Dict(u)time", 1000000, test_dict2);
-  if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
-  if (n == 43)
-    test_function("DictS(u)  time", 1000000, test_dict_str);
-  if (n == 44)
-    test_function("DictS(m)  time", 1000000, test_dict_str2);
-  if (n == 50)
-    test_function("Sort   time", 10000000, test_sort);
-  if (n == 51)
-    test_function("Stable Sort time", 10000000, test_stable_sort);
+  test("STL", numberof(table), table, argc, argv);
  exit(0);
 }
@@ -0,0 +1,323 @@
+/*
+ * M*LIB - String Bench
+ *
+ * Copyright (c) 2017-2023, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#define NDEBUG
+
+#include <string>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#define M_USE_SMALL_NAME 0
+#include "common.h"
+
+#include "m-string.h"
+
+#ifdef BENCH_CAN_USE_SDS
+extern "C" {
+#include "sds.h"
+};
+#endif
+
+#ifdef BENCH_CAN_USE_BSTRLIB
+#include "bstrlib.h"
+#include "bstrwrap.h"
+#include "bstraux.h"
+#endif
+
+#if defined(BENCH_CAN_USE_POTTERY)
+#include "pottery/string/string.h"
+#endif
+
+/*
+ * BENCH
+ * 2000000
+ * 1. Generate N strings of random numbers 32 bits.
+ * 2. Concat all strings in a string usigned a random permutation of N.
+ * 3. Replace "1234" in the string into "WELL" until nothing remains.
+ * 4. Replace "56789" in the string into "DONE" until nothing remains.
+ * Return the final string length.
+ */
+
+unsigned *permutation_tab = NULL;
+
+void random_permutation(unsigned n)
+{
+  if (permutation_tab) free(permutation_tab);
+  permutation_tab = (unsigned *) malloc(n * sizeof(unsigned));
+  if (permutation_tab == NULL) abort();
+  for(unsigned i = 0; i < n; i++)
+    permutation_tab[i] = i;
+  for(unsigned i = 0; i < n; i++) {
+    unsigned j = rand_get() % n;
+    unsigned k = rand_get() % n;
+    unsigned l = permutation_tab[j];
+    permutation_tab[j] = permutation_tab[k];
+    permutation_tab[k] = l;
+  }
+}
+
+using namespace std;
+
+static void replace_all_stl(string &str, const char pattern[], const char replace[])
+{
+  size_t pos = 0;
+  do {
+    pos = str.find(pattern, pos);
+    if (pos != string::npos) {
+      str.replace (pos, strlen(pattern), replace);
+    }
+  } while (pos != string::npos);
+}
+
+size_t bench_stl(unsigned n)
+{
+  vector<string> tab;
+  tab.resize(n);
+  for(unsigned i = 0; i < n; i++)
+    tab[i] = to_string(rand_get());
+
+  string str;
+  for(unsigned i = 0; i < n; i++) {
+    str += tab[permutation_tab[i]];
+  }
+
+  replace_all_stl(str, "1234", "WELL");
+  replace_all_stl(str, "56789", "DONE");
+
+  return str.length();
+}
+
+size_t bench_mlib(unsigned n)
+{
+  m_string_t *tab = (m_string_t*) malloc (n * sizeof (m_string_t));
+  assert (tab != 0);
+  // P1
+  for(unsigned i = 0; i < n; i++) {
+    m_string_init(tab[i]);
+    m_string_set_ui(tab[i], rand_get());
+  }
+  // P2
+  m_string_t str;
+  m_string_init(str);
+  for(unsigned i = 0; i < n; i++) {
+    m_string_cat(str, tab[permutation_tab[i]]);
+  }
+  // P3
+  m_string_replace_all_cstr(str, "1234", "WELL");
+  m_string_replace_all_cstr(str, "56789", "DONE");
+  size_t length = m_string_size(str);
+
+  // Clean
+  m_string_clear(str);
+  for(unsigned i = 0; i < n; i++) {
+    m_string_clear(tab[i]);
+  }
+  free(tab);
+  return length;
+}
+
+
+#ifdef BENCH_CAN_USE_BSTRLIB
+
+static void replace_all_bstrlib(CBString &str, const char pattern[], const char replace[])
+{
+  size_t pos = 0;
+  do {
+    pos = str.find(pattern, pos);
+    if (pos != string::npos) {
+      str.replace (pos, strlen(pattern), replace);
+    }
+  } while (pos != string::npos);
+}
+
+size_t bench_bstrlib(unsigned n)
+{
+  vector<CBString> tab;
+  tab.resize(n);
+  for(unsigned i = 0; i < n; i++) {
+    char tmp[10];
+    sprintf(tmp, "%u", rand_get());
+    tab[i] = tmp;
+  }
+
+  CBString str;
+  for(unsigned i = 0; i < n; i++) {
+    str += tab[permutation_tab[i]];
+  }
+
+  replace_all_bstrlib(str, "1234", "WELL");
+  replace_all_bstrlib(str, "56789", "DONE");
+
+  return str.length();
+}
+#endif
+
+#ifdef BENCH_CAN_USE_SDS
+sds SDS_replace_at(sds str, size_t pos, size_t len, const char str2[])
+{
+  // simple implementation as replace is not available
+  sds a = sdsnewlen((const void*) str, pos);
+  a = sdscat(a, str2);
+  a = sdscat(a, &str[pos+len]);
+  sdsfree(str);
+  return a;
+}
+
+sds replace_all_sds(sds str, const char pattern[], const char replace[])
+{
+  size_t pos = 0;
+  do {
+    char *p = strstr(&str[pos], pattern);
+    pos = p == NULL ? -1U : (p - str);
+    if (pos != -1U) {
+      str = SDS_replace_at(str, pos, strlen(pattern), replace);
+    }
+  } while (pos != -1U);
+  return str;
+}
+
+size_t bench_sds(unsigned n)
+{
+  sds *tab = (sds*) malloc (n * sizeof (sds));
+  assert (tab != 0);
+  // P1
+  for(unsigned i = 0; i < n; i++) {
+    tab[i] =  sdsfromlonglong(rand_get());
+  }
+  // P2
+  sds str = sdsempty();
+  for(unsigned i = 0; i < n; i++) {
+    str = sdscat(str, tab[permutation_tab[i]]);
+  }
+  // P3
+  str = replace_all_sds(str, "1234", "WELL");
+  str = replace_all_sds(str, "56789", "DONE");
+  // Clean
+  size_t length = sdslen(str);
+  sdsfree(str);
+  for(unsigned i = 0; i < n; i++) {
+    sdsfree(tab[i]);
+  }
+  free(tab);
+  return length;
+}
+#endif
+
+#if defined(BENCH_CAN_USE_POTTERY)
+
+size_t pottery_find_cstr(string_t *b, size_t index, const char *pattern)
+{
+  // I cannot find such function in the API
+  const char *s = string_cstr(b);
+  const char *r = strstr(&s[index], pattern);
+  return r == NULL ? SIZE_MAX : r - s;
+}
+
+void pottery_replace_all_str(string_t *str, const char *s, const char *d)
+{
+  size_t i = 0;
+  while (true) {
+    i = pottery_find_cstr(str, i, s);
+    if (i==SIZE_MAX) return;
+    string_remove(str, i, strlen(s));
+    string_insert_cstr(str, i, d);
+  }
+}
+
+size_t bench_pottery(unsigned n)
+{
+  string_t *tab = (string_t*) malloc (n * sizeof (string_t));
+  assert (tab != 0);
+  // P1
+  for(unsigned i = 0; i < n; i++) {
+    string_init(&tab[i]);
+    string_append_format(&tab[i], "%u", rand_get());
+  }
+  // P2
+  string_t str;
+  string_init(&str);
+  for(unsigned i = 0; i < n; i++) {
+    string_append_string(&str, &tab[permutation_tab[i]]);
+  }
+  // P3
+  
+  pottery_replace_all_str(&str, "1234", "WELL");
+  pottery_replace_all_str(&str, "56789", "DONE");
+  size_t length = string_length(&str);
+
+  // Clean
+  string_clear(&str);
+  for(unsigned i = 0; i < n; i++) {
+    string_clear(&tab[i]);
+  }
+  free(tab);
+  return length;
+}
+#endif
+
+int main(int argc, const char *argv[])
+{
+  unsigned length, n = atoi(argv[1]);
+  unsigned select = atoi(argv[2]);
+  const char *name;
+  random_permutation(n);
+  rand_init();
+  unsigned long long t0 = cputime();
+
+  switch (select) {
+  case 0:
+    length = bench_mlib(n);
+    name = "MLIB";
+    break;
+  case 1:
+    length = bench_stl(n);
+    name = "STL";
+    break;
+#ifdef BENCH_CAN_USE_SDS
+  case 2:
+    length = bench_sds(n);
+    name = "SDS";
+    break;
+#endif
+#ifdef BENCH_CAN_USE_BSTRLIB
+  case 4:
+    length = bench_bstrlib(n);
+    name = "BSTRLIB";
+    break;
+#endif
+#if defined(BENCH_CAN_USE_POTTERY)
+  case 5:
+    length = bench_pottery(n);
+    name = "POTTERY";
+    break;
+#endif
+  default:
+    exit(0);
+  }
+  unsigned long long t1 = cputime();
+  printf("%5.5s LENGTH=%u T= %f s\n", name, length, (t1-t0) / 1000000.0 );
+
+  return 0;
+}
@@ -206,18 +206,16 @@ test_dict_big(size_t  n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 10,    "List", 10000000, 0, test_list, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 30,  "Rbtree", 1000000, 0, test_rbtree, 0},
+  { 40,    "dict", 1000000, 0, test_dict, 0},
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0}
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 10)
-    test_function("List   time",10000000, test_list);
-  if (n == 20)
-    test_function("Array  time", 100000000, test_array);
-  if (n == 30)
-    test_function("Rbtree time", 1000000, test_rbtree);
-  if (n == 40)
-    test_function("Dict   time", 1000000, test_dict);
-  if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
+  test("TommyDS", numberof(table), table, argc, argv);
  exit(0);
 }
@@ -1,4 +1,5 @@
 #define NDEBUG
+#define  _GNU_SOURCE

 #include <stdlib.h>
 #include <stdio.h>
@@ -199,19 +200,16 @@ static void test_sort(size_t n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 10,    "List", 10000000, 0, test_list, 0},
+  { 20,   "Array", 100000000, 0, test_array, 0},
+  { 40,    "dict", 1000000, 0, test_dict, 0},
+  { 41, "dictBig", 1000000, 0, test_dict_big, 0},
+  { 50,    "sort", 10000000, 0, test_sort, 0}
+};
+
 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]): 0;
-  if (n == 10)
-    test_function("List   time",10000000, test_list);
-  if (n == 20)
-    test_function("Array  time", 100000000, test_array);
-  if (n == 40 || n == 42)
-    test_function("Dict   time", 1000000, test_dict);
-  if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
-  if (n == 50)
-    test_function("Sort   time", 10000000, test_sort);
+  test("UT-HASH", numberof(table), table, argc, argv);
  exit(0);
 }
-
@@ -31,17 +31,12 @@ static void test_hash(size_t n)

 /********************************************************************************************/

+const config_func_t table[] = {
+  { 70,"XXHASH64", 100000000, test_hash_prepare, test_hash, test_hash_final}
+};

 int main(int argc, const char *argv[])
 {
-  int n = (argc > 1) ? atoi(argv[1]) : 0;
-  if (n == 70) {
-    n = (argc > 2) ? atoi(argv[2]) : 100000000;
-    test_hash_prepare(n);
-    test_function("XXHASH64 time", n, test_hash);
-    test_hash_final();
-  }
-  
+  test("XXHASH", numberof(table), table, argc, argv);
  exit(0);
 }
-
@@ -0,0 +1,306 @@
+/*
+ * M*LIB - common functions for bench module
+ *
+ * Copyright (c) 2017-2023, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <string.h>
+#include "common.h"
+
+// Maximum supported value for repeat argument
+#define MAX_REPEAT 10000
+
+// The global result
+unsigned long g_result;
+
+// The rand value
+#if defined(MULTI_THREAD_MEASURE)
+M_THREAD_ATTR
+#endif
+unsigned int randValue = 0;
+
+void compiler_barrier(void *p)
+{
+  // Do nothing, but let the compiler thinks that we did.
+  (void) p;
+  // Can be used for FLTO building
+  //  asm volatile("": "+r" (p) : :"memory");
+}
+
+struct parse_opt_s {
+  int test_function;
+  double from, to, step, grow;
+  double within;
+  unsigned repeat;
+  bool graph, best, best_within, average, quiet;
+};
+
+static void
+parse_config(struct parse_opt_s *opt, int argc, const char *argv[])
+{
+  char *end;
+  
+  opt->test_function = 0;
+  opt->from = 0.0;
+  opt->to   = 0.0;
+  opt->step = 0.0;
+  opt->grow = 1.1;
+  opt->graph = false;
+  opt->best = false;
+  opt->best_within = false;
+  opt->average = false;
+  opt->quiet = false;
+  opt->repeat = 1;
+  opt->within = .05;
+  
+  for(int i = 1; i < argc ; i++)
+    {
+      if (argv[i][0] == '-') {
+	if (strcmp(argv[i], "--from") == 0){
+	  i++;
+	  opt->from = strtod(argv[i], &end);
+	  opt->to   = opt->from;
+	} else if (strcmp(argv[i], "--to") == 0) {
+	  i++;
+	  opt->to = strtod(argv[i], &end);
+	  opt->grow = 1.1;
+	} else if (strcmp(argv[i], "--step") == 0) {
+	  i++;
+	  opt->step = strtod(argv[i], &end);
+	  opt->grow = 0;
+	} else if (strcmp(argv[i], "--grow") == 0) {
+	  i++;
+	  opt->grow = strtod(argv[i], &end);
+	  opt->step = 0;
+	} else if (strcmp(argv[i], "--repeat") == 0) {
+	  i++;
+	  opt->repeat = strtol(argv[i], &end, 10);
+	  opt->repeat = (opt->repeat > MAX_REPEAT) ? MAX_REPEAT : opt->repeat;
+	} else if (strcmp(argv[i], "--graph") == 0) {
+	  opt->graph = true;
+	} else if (strcmp(argv[i], "--best") == 0) {
+	  opt->best = true;
+	  opt->average = false;
+	  opt->best_within = false;
+	} else if (strcmp(argv[i], "--best-within") == 0) {
+	  opt->best_within = true;
+	  opt->best = false;
+	  opt->average = false;
+	  i++;
+	  opt->within = strtod(argv[i], &end) / 100.0;
+	} else if (strcmp(argv[i], "--average") == 0) {
+	  opt->average = true;
+	  opt->best = false;
+	  opt->best_within = false;
+	} else if (strcmp(argv[i], "--quiet") == 0) {
+	  opt->quiet = true;
+	} else {
+	  fprintf(stderr, "ERROR: Option unkown: %s.\n",
+		  argv[i]);
+	  exit(-1);
+	}
+	if (*end != 0) {
+	  fprintf(stderr, "ERROR: Cannot parse %s. Expected float\n",
+		  argv[i]);
+	  exit(-1);
+	}
+
+      } else {
+	opt->test_function = strtol (argv[i], &end, 10);
+	if (*end != 0) {
+	  fprintf(stderr, "ERROR: Cannot parse %s. Expected function number\n",
+		  argv[i]);
+	  exit(-1);
+	}
+      }
+    }
+}
+
+static int
+select_config(int func, size_t n, const config_func_t functions[])
+{
+  for(size_t i = 0; i < n;i++) {
+    if (functions[i].num == func)
+      return i;
+  }
+  fprintf(stderr, "ERROR: Function number %d not found. Available functions are:\n", func);
+  for(size_t i = 0; i < n;i++) {
+    fprintf(stderr, "  %d: %s\n", functions[i].num, functions[i].funcname);
+  }
+  fprintf(stderr,
+	  "USAGE: FUNC_NUMBER [--from number --to number (--grow number | --step number)] [--graph]\n"
+	  "[--repeat number] [--best|--average|--best-within] [--quiet]\n");
+  exit(-1);
+}
+
+// Utility function for qsort
+static int cmp_double(const void *pa, const void *pb)
+{
+  const double *a = (const double *) pa, *b = (const double *)pb;
+  return (*a < *b) ? -1 : *a > *b;
+}
+
+/* Get the longest sequence of values within 'f'% */
+static int
+get_sequence(int i, int n, double tab[], double f)
+{
+  int j;
+  for(j = i + 1; j < n; j++) {
+    if (tab[j] > f * tab[i])
+      break;
+  }
+  return j-i;
+}
+
+/* Return the minimum of the longest sequence of values with 'f'% */
+static double
+get_best_within(int n, double tab[], double f)
+{
+  qsort(tab, n, sizeof(double), cmp_double);
+  int best_i   = 0;
+  int best_seq = get_sequence(0, n, tab, f);
+  for(int i = 1; i < n && (n-i) > best_seq ; i++) {
+    int seq = get_sequence(i, n, tab, f);
+    if (seq > best_seq) {
+      best_i = i;
+      best_seq = seq;
+    }
+  }
+  return tab[best_i];
+}
+
+// Integer sqrt function (to avoid depending on libm)
+static unsigned integer_sqrt(unsigned n)
+{
+  // Find greatest shift.
+  int shift = 2;
+  unsigned nShifted = n >> shift;
+  // We check for nShifted being n, since some implementations
+  // perform shift operations modulo the word size.
+  while (nShifted != 0 && nShifted != n){
+    shift += 2;
+    nShifted = n >> shift;
+  }
+  shift -= 2;
+  // Find digits of result.
+  unsigned result = 0;
+  while (shift >= 0) {
+    result = result << 1;
+    unsigned candidateResult = result + 1;
+    if (candidateResult*candidateResult <= n >> shift) {
+      result = candidateResult;
+    }
+    shift -= 2;
+  }
+  return result;
+}
+
+void
+test(const char library[], size_t n, const config_func_t functions[], int argc, const char *argv[])
+{
+  // Init & parse arguments
+  // NUMBER
+  // --from NUMBER --to NUMBER --step NUMBER --grow NUMBER
+  // --graph --best --average --quiet
+  // --repeat N
+  struct parse_opt_s arg;
+  parse_config(&arg, argc, argv);
+  int i = select_config(arg.test_function, n, functions);
+  double from = (arg.from == 0) ? functions[i].default_n : arg.from;
+  double to   = (arg.to   == 0) ? functions[i].default_n : arg.to;
+
+  // Open plot file if needed
+  FILE *graph_file = NULL;
+  if (arg.graph) {
+    char filename[100];
+    sprintf(filename, "plot-%s-%d.dat", library, arg.test_function);
+    graph_file = fopen(filename, "wt");
+    if (!graph_file) {
+      fprintf(stderr, "ERROR: Cannot create the file '%s'\n", filename);
+      exit(-2);
+    }
+    fprintf(graph_file, "# plotting %s-%d : %s\n# N T", library, arg.test_function, functions[i].funcname);
+  }
+  
+  // Do the bench
+  for(double n = from; n <= to ; n = ((arg.grow == 0) ? n + arg.step : n * arg.grow))
+    {
+      double best = (1.0/0.0);
+      double avg  = 0.0;
+      double variance = 0.0;
+      static double measure[MAX_REPEAT];
+      double ba = 0.0;
+      
+      if (functions[i].init != NULL)
+	functions[i].init(n);
+
+      // Measure the time of the test_function
+      for(unsigned r = 0; r < arg.repeat; r++) {
+	double t0 = test_function( (arg.graph|arg.best|arg.average|arg.quiet) ? NULL : functions[i].funcname, (size_t) n, functions[i].func);
+	best = (t0 < best) ? t0 : best;
+	avg += t0;
+	variance += t0 * t0;
+	measure[r] = t0;
+      }
+
+      // Closure of the tests
+      if (functions[i].clear != NULL)
+	functions[i].clear();
+
+      // Finish computing the different times
+      if (arg.repeat > 1) {
+	avg /= arg.repeat;
+	variance = (variance - arg.repeat * avg * avg) / (arg.repeat - 1);
+	ba = get_best_within(arg.repeat, measure, 1. + arg.within);
+      } else {
+        ba = avg;
+      }
+      
+      // The average value shall be around best_within (and greater)
+      // otherwise the result doesn't seem reliable.
+      bool reliable = (ba <= avg && ba * (1.0+arg.within/2) + 0.5 > avg);
+      
+      // Print the result
+      if (arg.graph) {
+	fprintf(graph_file, "%f %f\n", n, arg.average ? avg : arg.best ? best : ba);
+      } else if (arg.quiet) {
+	printf("%ld\n", (long)(arg.average ? avg : arg.best ? best : reliable ? ba : -1));
+      } else if (arg.repeat > 1) {
+	if (arg.average == false && arg.best_within == false)
+	  printf ("%20.20s time %lu ms for n = %lu ***   BEST  ***\n", functions[i].funcname, (unsigned long) best, (unsigned long) n);
+	if (arg.best == false  && arg.best_within == false)
+	  printf ("%20.20s time %lu ms +/- %u ms for n = %lu *** AVERAGE ***\n", functions[i].funcname, (unsigned long) avg, 2*integer_sqrt(variance), (unsigned long) n);
+	if (arg.best == false  && arg.average == false)
+	  printf ("%20.20s time %lu ms for n = %lu *** BEST within %d%% *** %s\n", functions[i].funcname, (unsigned long) ba, (unsigned long) n, (int)(100*arg.within), reliable ? "" : "(unreliable result)");
+      }
+    }
+  
+  // Close the FILE if needed
+  if (arg.graph) {
+    fclose(graph_file);
+    printf("File plot-%s-%d.dat generated.\n"
+	   "Run in gnuplot the following command:\n"
+	   "\tplot 'plot-%s-%d.dat' with linespoints linestyle 1\n",
+	   library, arg.test_function, library, arg.test_function);
+  }
+  return;
+}
@@ -1,7 +1,7 @@
 /*
 * M*LIB - common functions for bench module
 *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -25,11 +25,40 @@
 #ifndef __COMMON_BENCH__H
 #define __COMMON_BENCH__H

+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+// Needed for M_THREAD_ATTR
+#if defined(MULTI_THREAD_MEASURE)
+#include "m-thread.h"
+#endif
+
+#if defined(_WIN32)
+# include <windows.h>
+#elif (defined(__APPLE__) && defined(__MACH__)) \
+  || defined(__DragonFly__) || defined(__FreeBSD__) \
+  || defined(__NetBSD__) || defined(__OpenBSD__)
+# include <sys/types.h>
+# include <sys/resource.h>
+# include <sys/time.h>
+# include <sys/param.h>
+# include <sys/sysctl.h>
+# define USE_SYSCTL
+#else
+# include <sys/types.h>
+# include <sys/resource.h>
+# include <sys/time.h>
+# include <unistd.h>
+#endif
+
+// Number of elements of a table
+#define numberof(x) (sizeof(x)/sizeof(x[0]))
+
+/* Get the current CPU time in microsecond. */
 #if defined(_WIN32)
 /* WINDOWS variant */
-#include <windows.h>
-
-static unsigned long long
+static inline unsigned long long
 cputime (void)
 {
  LARGE_INTEGER freq, val;
@@ -37,23 +66,18 @@ cputime (void)
  QueryPerformanceCounter(&val);
  return (unsigned long long) (1000000. * (double) val.QuadPart / (double) freq.QuadPart);
 }
-
 #else
 /* UNIX variant */
-#include <sys/types.h>
-#include <sys/resource.h>
-#include <sys/time.h>
-
-static unsigned long long
+static inline unsigned long long
 cputime (void)
 {
 #if defined(MULTI_THREAD_MEASURE)
-  // Multi thread
+  // Multi thread: Uses real time
  struct timeval tv;
  gettimeofday (&tv, NULL);
  return tv.tv_sec * 1000000ULL + tv.tv_usec;
 #else
-  // Single thread
+  // Single thread: Uses process usage time
  struct rusage rus;
  getrusage (0, &rus);
  return rus.ru_utime.tv_sec * 1000000ULL + rus.ru_utime.tv_usec;
@@ -62,44 +86,60 @@ cputime (void)

 #endif

-unsigned long g_result;
+// The result of the bench
+extern unsigned long g_result;
+
+// The rand value
+extern
 #if defined(MULTI_THREAD_MEASURE)
 M_THREAD_ATTR
 #endif
-unsigned int randValue = 0;
+unsigned int randValue;

-static void rand_init(void)
+// Pseudo rand value generator.
+// Not very random but sufficient and fast enough for the bench
+static inline void rand_init(void)
 {
  randValue = 0;
 }
-static unsigned int rand_get(void)
+static inline unsigned int rand_get(void)
 {
  randValue = randValue * 31421U + 6927U;
  return randValue;
 }

-static void test_function(const char str[], size_t n, void (*func)(size_t))
+// The function that performs the bench
+static inline double
+test_function(const char *str, size_t n, void (*func)(size_t))
 {
+  double result;
  unsigned long long start, end;
  rand_init();
  start = cputime();
  (*func)(n);
  end = cputime();
-  end = (end - start) / 1000U;
-  printf ("%s %lu ms for n = %lu [r=%lu]\n", str, (unsigned long) end, (unsigned long) n, g_result);
+  result = (double)(end-start) / 1000.0;
+  if (str != NULL) {
+    printf ("%20.20s time %.2f ms for n = %lu [r=%lu]\n", str, result, (unsigned long) n, g_result);
+  }
+  return result;
 }

-#if defined(_WIN32)
-# include <windows.h>
-#elif (defined(__APPLE__) && defined(__MACH__)) \
-  || defined(__DragonFly__) || defined(__FreeBSD__) \
-  || defined(__NetBSD__) || defined(__OpenBSD__)
-# include <sys/param.h>
-# include <sys/sysctl.h>
-# define USE_SYSCTL
-#else
-# include <unistd.h>
+// Configuration table
+typedef struct {
+  int num;
+  const char *funcname;
+  size_t default_n;
+  void (*init)(size_t);
+  void (*func)(size_t);
+  void (*clear)(void);
+} config_func_t;
+
+// Perform a parsing of the given arguments and do the bench according to the table
+#ifdef __cplusplus
+extern "C"
 #endif
+void test(const char library[], size_t n, const config_func_t functions[], int argc, const char *argv[]);

 /* Return the number of CPU of the system */
 static inline int get_cpu_count(void)
@@ -123,4 +163,9 @@ static inline int get_cpu_count(void)
 #endif
 }

+#ifdef __cplusplus
+extern "C"
+#endif
+void compiler_barrier(void *p);
+
 #endif
@@ -1,7 +1,7 @@
 /*
 * MLIB - TEST module
 *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2023, Patrick Pelissier
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -59,7 +59,7 @@ static void find_max(void)
    dict_int64_set_at (dict, get_rand(), get_rand());
    n++;
    if ((n & ((1<<20)-1)) == 0) {
-      printf ("n=%lu\n", n);
+      printf ("n=%zu\n", n);
    }
  }
  dict_int64_clear(dict);
@@ -35,10 +35,9 @@ static inline size_t my_hash(uint64_t key)
 {
  return ((key) ^ (key)>>7);
 }
-static inline void update_val(uint32_t *p, uint32_t v) { *p += v;}
 DICT_OA_DEF2(dict_oligonucleotide,
             uint64_t, M_OPEXTEND(M_DEFAULT_OPLIST, HASH(my_hash), OOR_EQUAL(my_oor_equal_p), OOR_SET(my_oor_set M_IPTR)),
-             uint32_t, M_OPEXTEND(M_DEFAULT_OPLIST, UPDATE(update_val M_IPTR)))
+             uint32_t, M_DEFAULT_OPLIST)
 #define M_OPL_dict_oligonucleotide_t() DICT_OPLIST(dict_oligonucleotide, M_OPEXTEND(M_DEFAULT_OPLIST, HASH(my_hash), OOR_EQUAL(my_oor_equal_p), OOR_SET(my_oor_set M_IPTR)), M_DEFAULT_OPLIST)

 // Define a B*TREE-21 of uint32_t --> uint64_t and register its oplist
@@ -1,8 +1,3 @@
-#ifndef NDEBUG
-#define NDEBUG
-#endif
-#undef NDEBUG
-
 #include <string.h>

 #include "benchmark.h"
@@ -48,7 +43,7 @@ int test_int(int N, const unsigned *data)
      if (dict_int_get (h, data[i]) == NULL) {
        dict_int_set_at (h, data[i], i);
      } else {
-        dict_int_remove(h, data[i]);
+        dict_int_erase(h, data[i]);
      }
    }
    ret = (int)dict_int_size(h);
@@ -64,7 +59,7 @@ int test_str(int N, char * const *data)
      if (dict_str_get (h, data[i]) == NULL) {
        dict_str_set_at (h, data[i], i);
      } else {
-        dict_str_remove(h, data[i]);
+        dict_str_erase(h, data[i]);
      }
    }
    ret = (int)dict_str_size(h);
@@ -4,10 +4,10 @@
 #include "m-dict.h"
 #include "m-mempool.h"

-DICT_DEF2(dict_int,
+DICT_STOREHASH_DEF2(dict_int,
          int, M_OPEXTEND(M_DEFAULT_OPLIST, MEMPOOL(mpool_int), MEMPOOL_LINKAGE(static)),
          int, M_DEFAULT_OPLIST)
-DICT_DEF2(dict_str,
+DICT_STOREHASH_DEF2(dict_str,
          const char *, M_OPEXTEND (M_CSTR_OPLIST, MEMPOOL(mpool_str), MEMPOOL_LINKAGE(static)),
          int, M_DEFAULT_OPLIST)

@@ -20,7 +20,7 @@ int test_int(int N, const unsigned *data)
      if (dict_int_get (h, data[i]) == NULL) {
        dict_int_set_at (h, data[i], i);
      } else {
-        dict_int_remove(h, data[i]);
+        dict_int_erase(h, data[i]);
      }
    }
    ret = (int)dict_int_size(h);
@@ -38,7 +38,7 @@ int test_str(int N, char * const *data)
      if (dict_str_get (h, data[i]) == NULL) {
        dict_str_set_at (h, data[i], i);
      } else {
-        dict_str_remove(h, data[i]);
+        dict_str_erase(h, data[i]);
      }
    }
    ret = (int)dict_str_size(h);
@@ -1,4 +1,5 @@
 #include "../common.c"
+#define M_USE_DICT_OA_PROBING(s) 1
 #include "m-dict.h"

 static inline bool oor_equal_p(unsigned int k, unsigned char n)
@@ -11,10 +12,10 @@ static inline void oor_set(unsigned int *k, unsigned char n)
 }

 DICT_OA_DEF2(dict_oa_uint,
-	     unsigned int, M_OPEXTEND(M_DEFAULT_OPLIST, OOR_EQUAL(oor_equal_p), OOR_SET(oor_set M_IPTR)),
+	     unsigned int, M_OPEXTEND(M_DEFAULT_OPLIST, HASH(hash_fn), OOR_EQUAL(oor_equal_p), OOR_SET(oor_set M_IPTR)),
 	     unsigned int, M_DEFAULT_OPLIST)

-void test_int(uint32_t n, uint32_t x0)
+uint32_t test_int(uint32_t n, uint32_t x0)
 {
  uint32_t i, x, z = 0;
  dict_oa_uint_t h;
@@ -22,10 +23,12 @@ void test_int(uint32_t n, uint32_t x0)
  for (i = 0, x = x0; i < n; ++i) {
    x = hash32(x);
    unsigned int key = get_key(n, x);
-    unsigned int *ptr = dict_oa_uint_get(h, key);
-    if (ptr) { (*ptr)++; z+= *ptr; }
-    else { dict_oa_uint_set_at(h, key, 1); z+=1; }
+    unsigned int *ptr = dict_oa_uint_get_at(h, key);
+    (*ptr)++;
+    z += *ptr;
  }
  fprintf(stderr, "# unique keys: %d; checksum: %u\n", (int) dict_oa_uint_size(h), z);
+  z = dict_oa_uint_size(h);
  dict_oa_uint_clear(h);
+  return z;
 }
@@ -35,3 +35,50 @@ V0.2.*: * worker_start takes a 'worker_t' as an additional parameter
        The provided _remove doesn't use an iterator but a 'key', incompatible with the one of array or list.
        But is like the one provided by the priority queue.
        
+V0.3.*: * Remove B+TREE _remove method as it has been deprecated (use _erase instead)
+        * Remove DICT _remove method as it has been deprecated (use _erase instead)
+        * Make _it_to_p method of B+TREE / RB-TREE as deprecated (uses _it_until_p instead ).
+        * Deprecated buffer options BUFFER_BLOCKING* and BUFFER_UNBLOCKING*
+        as the _push_blocking and _pop_blocking functions can do the same and are more versatil.
+	* Iteration over the items of a dictionnary/tree returns const iterators for access through
+	OPLIST (impact: algorithm & M_EACH) as the IT_REF operator is no longer exported.
+	The _it_ref method is still defined and can be used, so you can still modify the values
+	but it won't be automatically used anymore (as the keys CANNOT be modified).
+	(Previously it generates incorrect algorithm when used with m-dict).
+
+V0.4.*: * The order of a list initialized using M_LET is reversed
+        to match what is done for ARRAY (and the C++ forward_list).
+        * Rename M_SKIP, M_KEEP & M_MID into M_SKIP_ARGS, M_KEEP_ARGS & M_MID_ARGS
+        due to conflict with glibc malloc.h (that defines M_KEEP for compatibility).
+        * Method write_string of m_serial expects a new argument (number of characters).
+        * Method _init_set2 of m-i-shared is removed.
+        * Operator _it_insert updates it_insertion iterator to reference the inserted element.
+        * Dereference Type of an iterator of a dict / B+Tree is suffixed by _itref_t instead of _type_t.
+        * Rename TUPLE _init_set2 in _init_emplace & _set2 in _emplace.
+        * Rename Priority Queue method _update_further in _update.
+        
+V0.5.*: * M_INVERT is renamed into M_REVERSE to be more coherent with the REVERSE operator.
+          M_INVERT is marked as obsolete.
+        * Remove _it_to_p method of B+TREE / RB-TREE as it has been deprecated.
+        * Remove ALGO_INIT_VA & M_ALG0_LET_INIT_VAI of m-algo as it has been deprecated (Use of M_LET instead).
+        * Some Internal name of user modifiable macros have been renamed to be properly 
+        customizable by the user.
+        * Rename M_HASH_SEED into M_USE_HASH_SEED (as it is a user macro).
+        * M_LET: for initialization of variable with arguments, if there is only one argument, 
+        it will default to use INIT_SET instead of INIT_WITH.
+        ==> Encapsulate the argument between () to force use of INIT_WITH.
+        * Remove of UPDATE operator. Use of SET for RBTREE or ADD for DICT instead.
+        * Make the _clean suffix for reseting the container to empty deprecated. Use new _reset suffix instead.
+        * Make the _get_at suffix for always getting a value deprecated. Use new _safe_get suffix instead.
+	* Rename CLEAN operator in RESET operator.
+	* Rename GET_SET_KEY operator in SAFE_GET_KEY operator.
+	
+V0.6.*: * Rename M_DEFAULT_OPLIST in M_BASIC_OPLIST
+        * Remove experimental macro M_IF_DEFAULT1.
+        * Remove M_INVERT
+        * String functions with _str suffix for C strings have been renamed with _cstr suffix (like string_cat_str ==> m_string_cat_cstr)
+        Note: the compatible layer still keeps the old naming,
+        so except if you are using the prefixed version of the strings
+        or the bounded strings API, you won't need to upgrade your code.
+        
+V0.7.*: * Rename m-mutex.h header in m-thread.h
@@ -17,17 +17,35 @@ How to make a release?
 In case of problem, open a problem report.


-List of tested systems
-=======================
+List of automatically tested systems
+====================================

-* gcc 4.9, 7 & 8 on linux/x86-64
-* clang 3.5, 4 & 6 on linux/x86-64
-* g++ 7 & 8 on linux/x86-64
+* gcc on linux/x86-64 (32 bits and 64 bits)
+* g++ on linux/x86-64 (32 bits and 64 bits)
+* clang on macos/x86-64
+* clang++ on macos/x86-64
 * tcc on linux/x86-64
-* gcc 7 on windows/x86-64
-* gcc 4.9 on linux/powerpc
-* gcc 6 on linux/armv7l
-* clang 3.8 on linux/armv7l
+* gcc on windows/x86-64 (mingw)
+* msvc on windows/x86-64
+* clang on windows/x86-64
+
+List of manually tested systems
+===============================
+
+* clang on linux/x86-64
+* clang on linux/armv7l
+* gcc on linux/powerpc
+* gcc on linux/armv7l
+
+Atomic library
+==============
+
+For the targets armel, m68k, mips, mipsel, powerpc, powerpcspe or sh4,
+you may need to run the test suite by adding the atomic library:
+
+make check LDFLAGS="-pthread -latomic"
+
+since 'atomic' library is not automatically included for 32 bits systems.


 Cross compilation
@@ -35,7 +53,7 @@ Cross compilation

 There is no need to cross compile the library as it is a header only library.

-However if you want to run the test with a cross-compiler, do like the following
+However if you want to run the tests with a cross-compiler, do like the following
 command. It performs a cross-compilation of the test suite from linux to windows
 and run the test suite with wine:

@@ -47,9 +65,8 @@ Handling issues

 Issues are opened in the bug tracker of the project (typically https://github.com/P-p-H-d/mlib/issues )

-If the issue cannot be closed and taken into account in less than (typically) one month,
-or before a release,
-it shall be moved into the long term issues included in the repository:
+If the issue cannot be taken into account quickly and are long term,
+it should be moved into the long term issues included in the repository:
 https://github.com/P-p-H-d/mlib/blob/master/doc/ISSUES.org
 This is a file in ORG mode: the issues are created with the proper tags.

@@ -62,3 +79,78 @@ This will have the following gains:

 Once one issue of ISSUES.org is taken into account,
 its state shall be changed to DONE (the issue shall not be removed).
+
+
+Debugging
+=========
+
+Debugging the library can be quite difficult
+as it performs heavy preprocessing expansion
+and expands all code in one line.
+Different strategy for debugging the library itself are still possible:
+
+1) Good old printf.
+Add printf of interresting values in the debugged function.
+
+
+2) Preprocess the library and then compile the preprocessed file like this:
+
+          cc -std=c99 -E test-file.c > test-file.i
+          perl -pi -e 's/;/;\n/g' test-file.i
+          cc -std=c99 -c -Wall test-file.i
+
+ The resulting executable can be debugged much more easily.
+
+
+3) To debug the preprocessing itself, the Boot Wave library can be used
+and in particular the [wave driver](https://www.boost.org/doc/libs/1_71_0/libs/wave/doc/wave_driver.html)
+
+ Add in the code the following pragmas around the code to debug:
+
+     	  #pragma wave trace(enable)  
+     	  ARRAY_DEF (array_charp, char *)
+     	  #pragma wave trace(disable)
+
+Run the wave driver:
+
+    	 ./wave ex-array01.c -I .. --c99 -t test.trace
+
+The different expansion performed by the library are described in test.trace
+
+Coding rules
+============
+
+* Use of non standard C shall be protected under a specific compiler test,
+  so that the library remains compatible with a strict C99 compiler.
+
+* C11 features shall be optional.
+
+* Use 'make format' to format the header files properly.
+
+* External types shall be suffixed by _t and in lower case
+  but shall be optional if the user doesn't want then.
+
+* Internal types shall be suffixed by _ct and in lower case
+  (as confidential types)
+
+* External / Internal functions shall be in lower case.
+
+* External / Internal macros shall be in upper case.
+
+* Internal macros / functions shall be prefixed by m_<container>
+  with container is the name of the container with one letter transformed:
+      o --> 0
+      e --> 3
+      i --> 1
+      y --> 4
+  This prevents the automatic completion to work when the user starts writing its function.
+
+* Test functions shall be predicated and be suffixed by '_p'
+
+
+Misc
+====
+
+To put a breakpoint for the thread sanitizer in case of error, in gdb add:
+
+$ set env TSAN_OPTIONS=halt_on_error=1,abort_on_error=1
@@ -1,32 +1,413 @@
 *Long term issues*
------------------
+==========================================================

-* TODO #21: Generic Binary serialization                        :ENHANCEMENT:
+* TODO #33 : Handling of partially constructed object               :ANOMALY:

-   Based on issue #26 of  https://github.com/P-p-H-d/mlib/issues/26
+** State

-   Some kind of "binary serialization" on the model of get_str/parse_str 
-   could be possible. It would be a great feature from the application 
-   point-of-view: binary representation is more bandwidth-efficient if 
-   used on network communications.
+Support of partially constructed object needs special code to handle it 
+correctly (register a correct cleanup function in case of exception).

-   It will be good to have import/export methods to the 
-   XML/JSON/MSGPACK/PROTOBUF/BINARY format. 
-   However, adding all of them on by one in the M*LIB containers
-   doesn't seem satisfactory. 
+Current containers don't support such features.

-   Instead, adding a generic interface for the serialization of data 
-   that may be customized by the user to perform the import/export of
-   objects in whatever format they want into what they want (FILE/memory/...). 
-   To simplify it, this interface could only support one kind of import/export
-   per compilation unit.
+** Actions

-   Problem:
-   the interface is either too high level (limiting too much what we can do)
-   or too low level (exporting too many internal things of the library).
+Add such support in M*LIB containers. 
+
+It can be difficult. For example, for array _init_set
+function due to the copy of the object one per one. Each copied sub object
+may throw an exception, so we always need to have the container in a correct
+state so that it can be cleanup.
+
+* TODO #32 : User specialization fields in the container        :ENHANCEMENT:
+
+** State
+
+Some methods of a contained object may need to have some options that 
+are neither constant nor global, but are specialized in function of the container.
+
+For example, a memory handler may need a parameter which is needed to identify
+which pool of memory has to be used.
+
+** Plan:
+
+Add a new operator "CONTEXT" which is a type to be added in the 
+defined container. Then it can be accessed by the operator through an extension
+of the GAIA by adding support for identification of specialization like this:
+
+     ( CONTEXT( memory_pool_ref ),
+       NEW( API(NONE, memory_pool_alloc, CONTEXT, ARG1)),
+       DEL( API(NONE, memory_pool_free, CONTEXT, ARG1)) )
+
+** Open points:
+
+- How to get access to the specialization field of the container? ==> Define the "self" name as the name of the container for all methods? What to do when there are several containers for a method?
+- How to initialize the specialization field of the container? provide custom initialization functions? It seems to be the hard point.
+
+* TODO #31 : Uniformize parametrisation options of containers   :ENHANCEMENT:
+
+** State 
+
+Currently in order to pass some parametrization of the containers,
+the parameters are passed to the generation macros through:
+
+- extra parameters of the macros,
+- special operators of the contained object oplist.
+
+The extra parameters of some generation macros break the uniformity
+of the interface.
+It is conceptually wrong to put some special operators of the contained object 
+that have only meanings for the container object.
+In case of adding new options, it break the existing interface or put another
+operator in the contained object oplist.


-* TODO #20: Bucket priority queue                               :ENHANCEMENT:
+The following parameters are used:
+
+- Fixed size of a queue (buffer / B+Tree),
+- Policy of a queue (buffer),
+- Type of the container, IT type of the container, Ref type of the iterator
+
+The following operators are used:
+
+- NEW / DEL / REALLOC / FREE
+- MEMPOOL / MEMPOOL_LINKAGE
+
+The following new options is planned:
+
+- Interface (See #28)
+- Extra parameter for memory allocation function 
+
+** Plan
+
+The M\_*\_DEF\_AS macros shall be changed like this:
+
+    M_*_DEF_AS(name, cont_oplist, type[, type_oplist])
+
+with cont\_oplist being the container oplist that gives parametrization to the container definition.
+The following operators are planned:
+
+- TYPE: to define the type of the container,
+- IT\_TYPE: to define the IT type of the container,
+- SUBTYPE: to define the type pointed by the iterator,
+- FIXED\_SIZE: to define the fixed size of a container,
+- POLICY: to define the policy of a container,
+- NEW / DEL / REALLOC / FREE: to define the memory interface,
+- MEMPOOL / MEMPOOL_LINKAGE: to request a definition of a specialized memory interface,
+- INTERFACE: to request a pure header definition, an implementation or both (see #28),
+- CONTEXT: to request an extra context parameter to add in the container.
+
+All operators should be optional.
+
+The NEW / DEL / REALLOC / FREE / MEMPOOL / MEMPOOL_LINKAGE won't have any effects anymore if defined in the contained object oplist.
+
+** Pro:
+
+- Uniformize interface
+
+** Con:
+
+- API breakage. It can be mitigated by providing an adaptating layer by prividing the new interface for M\_*\_DEF\_AS only
+and *\_DEF\_AS will provide a translation layer.
+
+* TODO #30 : Serialization rework                               :ENHANCEMENT:
+
+** State 
+Currently, each container supports 3 serialization methods:
+
+- old format to FILE 
+- old format to string
+- generic serialization 
+
+Generic serialiation connect the container format to the serialization object constraints.
+It is done through a vtable. As such there is a performance penality and it avoids proper inlining.
+
+** Evolution
+
+Old format should be deprecated and shall use the generic serialization interface.
+
+Serialization object shall provide an OPLIST of serialization.
+For example CORE will provide OLD Format oplist and serial-json will provide JSON format oplist.
+Each oplist will provide the suffix needed for the serialization, and the interface
+(see already existing interface).
+
+Then a container will generate specialized serialization methods for each provided oplist.
+
+Pros:
+
+- Faster
+- In the M*LIB philosphy: much like other oplist usage.
+
+Cons:
+
+- compatibility breakage.
+
+Open point:
+
+- how can a user add a new serialization object?
+- Can we make a generic serialization object to support migration path?
+
+** Example
+
+serial-json provides
+
+    #define M_SERIAL_1() (NAME(_json), READ_INT(...), WRITE_INT(...) )
+
+containers provides
+    
+    For i in 1 100 ; do 
+        if do exist M_SERIAL_ ## i () 
+             expand(SERIAL_METHOD with M_SERIAL_1())
+
+    SERIAL_METHOD(name, ....)
+      static inline m_serial_return_code_t                                        \
+      M_C(M_F(name, _out_serial),M_GET_NAME(serial_op) )(M_GET_TYPE(serial_op) f, const list_t list)               \
+
+* DONE #29 : Support of partial initialized object                  :ANOMALY:
+
+** State
+
+In case of exception during the construction of an object,
+if the object is partially constructed, there is no destructor to call.
+Therefore if there is some partially constructed object
+(with some fields already fully constructed), there will be some links.
+This is the same problem with C++
+
+** Proposition
+
+Provide new macros to perform the partial initialization before doing the remaining taf.
+Something like:
+
+    M_CHAIN_INIT( init_code, clear_code)
+
+or
+
+x is { string_t s; string_t d; int num; }
+
+void struct_init_set(struct_t x, const struct_t y)
+{
+    // First thing is Chained Initialization
+    M_CHAIN_INIT( string_init_set(x->s, y->s), string_clear(x->s) );
+    M_CHAIN_INIT( string_init_set(x->d, y->d), string_clear(x->d) );
+    // End of chain init
+    x->num = y->num;
+}
+
+M_CHAIN_INIT will push the clean code pretty much like M_LET.
+Everything else is done in M_LET: when the constructor fully returns,
+the index of the clean code to call is reset to its value before calling
+the constructor. It means that the partially initialized code will be removed
+from this stack before the clean method of the structure itself is pushed.
+
+If an exception is raised after a M_CHAIN_INIT, only the clean methods
+of the M_CHAIN_INIT are called.
+
+* TODO #28 : Separate generation of interface to implementation :ENHANCEMENT:
+
+Enable support for generating an interface only for the headers
+and an implementation only for the source code.
+
+Try to keep API compatibility
+==> Only modify renamed macro with M_ prefix by giving a new mandatory
+argument for such generation.
+
+This argument is a generation parametric argument.
+oplist is a parameter that define the property of the contained type.
+It could be used to pass this information but it will be an abuse of interface.
+Another argument is needed.
+
+Used arguments to parameter generation not related to the contained type:
+
+- memory interface (NEW / DEL / ...)
+- queue policy
+- fixed size for queue
+- fixed node size for B+Tree
+- generate static inline, public (extern) or private (define) functions.
+- name of the type.
+- name of the iterator
+- name of the iterated element.
+- ...
+
+Use another oplist as argument for M_.._DEF_AS (See #31)
+
+ M_BUFFER_DEF_AS(name, (TYPE(toto), FIXED_SIZE(10), POLICY(STACK), INTERFACE(header)), int, M_BASIC_OPLIST)
+
+* TODO #27 : Uniformization of m-buffer interface               :ENHANCEMENT:
+
+** State
+
+The m-buffer interface requires special argument to work:
+- size & policy for BUFFER,
+- policy only for the others.
+This is not uniform with the others generation macros and not uniform with each other.
+Moreover the others are the only one which can be used in a shared memory, so
+a fixed size will be good to have too for such interface.
+
+** Plan
+
+- Uniformization of the interface (See #31)
+- Provide static size for all QUEUE.
+
+* TODO #26 : Hash-Map for huge objects                          :ENHANCEMENT:
+
+Specialize Hashmap for huge objects on supported hardware:
+
+Based on OA hash map with taggued pointer (needs space for tagging):
+low bits = high bits of hash
+pointer to object { key, hash, value }
+
+Can solve collision without dereferencing object with 1/2^lowbits chances.
+NB: hash may be uneeded due to the small chances of collision.
+Reduce cache usage ==> Should be faster.
+Increase cache usage for very small object (integer).
+
+Use of pointer to avoid moving object on GC.
+
+On AMD64, only 48 bits of 64 bits are really used for addressing data.
+==> lowbits= 16
+Empty representation= 0 (hash can be 0. pointer cannot be it).
+Deleted representation = 1 (pointer cannot be zero)
+
+<---- PTR ----><-HASH->
+
+#+BEGIN_SRC C
+#define LOW_BITS 16
+#define ALIGNED_BITS 2
+void *get_ptr(int64_t x) { 
+  return (void*) ((x >> LOW_BITS) << ALIGNED_BITS);
+}         
+unsigned get_small_hash(int64_t x) {
+  return x & ((1<<LOW_BITS)-1);
+}
+#+END_SRC
+
+* TODO #25 : Support of error return model for error handling.  :ENHANCEMENT:
+
+Find a way to support error return code for the API in case of allocation
+failure.
+
+Any service that returns void shall return a "int" (or another type).
+In case of allocation failure, it shall return an error.
+M_CALL macro shall stop its execution if the service returns an error code
+and the error code represents an error (avoid rewritting everything)
+and throw back the error code (stopping the execution flow).
+
+Services returning already something shall not be modified.
+
+This model should be applied at the container level only and not globally.
+Different containers may need different levels of error handling.
+4 combinaison to take into account:
+
+==> ABORT on container / ABORT on used type: The current model
+==> ABORT on container / RETCODE on used type: Needs to abort on reported error.
+==> RETCODE on container / ABORT on used type: Nothing particular to note.
+==> RETCODE on container / RETCODE on used type: Forward retcode to caller.
+
+Find a way to make it while not making the code too complex 
+(try to keep as simple as possible).
+
+Using a specialized oplist for such containers (_OPLIST_RETCODE)
+using a specialized API for retcode:
+
+API_RET_*: that expands to
+
+     if (func(args) == 0) goto handler_exit_failure;
+
+Adding at the end of each service:
+     M_END_FUNCTION(cleanup_code) that expands to different cases:
+     M_END_FUNCTION_VALUE(cleanup_code, return_success, return_failure) that expands to different cases:
+
+ABORT/ABORT:
+     handler_exit_success: 
+     handler_exit_failure: 
+      return;
+
+ABORT/RETCODE:
+     handler_exit_success: 
+      return;
+     handler_exit_failure: 
+      RAISE_FATAL_ERROR
+
+RETCODE/ABORT
+     handler_exit_success: 
+      return SUCESS;
+     handler_exit_failure: 
+      cleanup_code
+      return FAILURE;
+
+RETCODE/RETCODE
+     handler_exit_success: 
+      return SUCESS;
+     handler_exit_failure: 
+      cleanup_code
+      return FAILURE;
+
+If really needed, the macro can be avoided and code can be hand written.
+
+Open points:
+
+- How to handle warnings on unused labels?
+- What about M_LET / M_EACH? Maybe only supports those.
+
+* TODO #24 : New MIN-MAX-HEAP container                         :ENHANCEMENT:
+
+See https://en.wikipedia.org/wiki/Min-max_heap
+as DPRIORITY_QUEUE_DEF ?
+
+NOTE: Needs for such container?
+
+* TODO #23 : Strict MOVE semantic to clarify                    :ENHANCEMENT:
+
+** State
+
+Some type may need to have a force MOVE semantic (for example, they can store
+pointer to themselves). Currently the INIT_MOVE & MOVE operators are more
+a help for performance than a strict semantic usage.
+
+** ARRAY container
+
+The ARRAY container doesn't support strict MOVE semantic for example.
+It is not a simple matter as it performs a realloc of the table, thus
+moving the data before they can be moved using MOVE. Two solutions:
+
+- New operator MOVE_SELF to fix a type after it has been moved.
+- If MOVE defined, force another table and then copy by hand the type. This will be slower and consumme more memory.
+
+** MOVE in OPLIST
+
+Proposal: do not export INIT_MOVE / MOVE operator in OPLIST if the MOVE operator is 
+compatible with a pure COPY semantic. An exported MOVE operator will tell 
+other containers than the type shall be carefully moved using the provided
+MOVE operator.
+
+For example for tuple, it shall
+
+- create an init_move operator if no one has disabled INIT_MOVE,
+- export the init_move operator if at least one has exported a INIT_MOVE and no one has disabled INIT_MOVE.
+
+** DO_INIT_MOVE operator
+
+DO_INIT_MOVE macro is not also fully working for structure
+defined with [1] tricks but without an explicit INIT_MOVE / MOVE
+operators as it uses MOVE_DEFAULT which is not (fully compatible).
+==> Analyse limitation and possible constraint usages.
+
+Being able to define a correct default for INIT_MOVE will be really good
+(compatible with trivial move copy).
+In such case, all INIT_MOVE & MOVE operators can be removed from oplist
+to only use the default, and theses operators can be disabled or defined
+only when really needed in the oplist.
+However creating a default INIT_MOVE macro seems problematic.
+If the type is typedef T t[1] then passing such an argument to a function, 
+will transform the argument to T*, and the type of the argument doesn't match
+what is expecting resulting in a move of the pointers, not a move of the design data.
+
+Defining this type seems possible with C11 _Generic and a TYPE in the oplist,
+but without C11 _Generic I don't see any way to define such macro.
+
+Without a way to write such a macro, the ticket seems pretty much a dead end.
+
+* TODO #20 : New: Bucket priority queue                         :ENHANCEMENT:

 Add a new kind of priority queue. 
 See https://en.wikipedia.org/wiki/Bucket_queue
@@ -42,22 +423,20 @@ except that we can scan 64 entries at a time).
 Check if we can use BITSET, or introduce fixed size BITSET or use ad-hock 
 implementation.

-
-* TODO #19: Intrusive Red Black Tree                            :ENHANCEMENT:
+* TODO #19 : New: Intrusive Red Black Tree                      :ENHANCEMENT:

 Add intrusive red black tree. 
+ Look also for AVL tree (NOTE: Is there a performance difference between the two?)

-
-* TODO #18: Missing methods                                     :ENHANCEMENT:
+* TODO #18 : Missing methods                                    :ENHANCEMENT:

 Some containers don't have all the methods they should.
 See the cells in yellow here:
 http://htmlpreview.github.io/?https://github.com/P-p-H-d/mlib/blob/master/doc/Container.html

+* TODO #17 : New: Ressource handler                             :ENHANCEMENT:

-* TODO #17: Ressource handler                                   :ENHANCEMENT:
-
- A ressouce handler which shall associated a unique handle to a ressource.
+ A global 'ressouce handler' which shall associated a unique handle to a ressource.
 The handle shall be unique for the ressource and shall not be reused.
 It is typically a 64 bits integers always incremented (even if the program
 creates one billion ressources per second, the counter won't overflow
@@ -82,175 +461,35 @@ http://htmlpreview.github.io/?https://github.com/P-p-H-d/mlib/blob/master/doc/Co

 How to handle multiple resource ? 

- * variant: works fine. Memory usage can be (much) higher than needed if there is a lot of dissimilarity between the size of the objects.
- * embedded the type in the ressource handler: more work, API more complex. Memory usage seems better.
+ * variant: Pro : easy. Con: Memory usage can be (much) higher than needed if there is a lot of dissimilarity between the size of the objects.
+ * embedded the type in the ressource handler: Con: more work, API more complex. Pro: Memory usage seems better.

-
-* TODO #16: Lock Free List                                      :ENHANCEMENT:
+* TODO #16 : New: Lock Free List                                :ENHANCEMENT:

 Implement a lock free list. Most of the difficulty is the memory reclamation part.
 Typically this lock free list shall be compatible with RCU method.

- A node can be in the following state:
+** First  step: backoff methods                                        :DONE:
+** Second step: lock free node pool :                                  :DONE:
+   Done as m-c-mempool header.

- FREE: Can be used for allocation.
- IN_USE: The node is currently used in the list.
- TO_BE_RECLAIMED: The node is semantically removed, but some others may still be used it.
+** Third  step: Implement generic lock free list on top of it.

- So separate lists shall be used for the memory handler.
- It shall also be compatible with NUMA and avoid putting all nodes in the same lists if possible:
- otherwise the head will become a hot spot and slow down everything.
+ The ABA problem is already taken into account by the memory alloctor
+ provided that the lock free list doesn't try to be smart.

- The ABA problem shall also be taken into account. Normaly with the provided state of the nodes,
- it should not be a problem. 
+ backoff has be used when using CAS.
 
- backoff should also be considered when using CAS.
+ Concurrent insertion / insertion and insertion / deletion and deletion / deletion shall be crefully analyzed when taken into account.
 
- Concurrent insertion / insertion and insertion / deletion and deletion / deletion shall be taken into account.
+ Questions:
+ - singly or doubly or dual push?
+ - needs to be logically deleted : needs a previous field
+   (NULL if not logically deleted) ? TBC

-** First step: lock free node pool :
+* DONE #14 : Memory allocation enhancement                      :ENHANCEMENT:

-*** API based on Lock-Free Queue List
-
- -- node_t is { node_t *next; uint ticket; data_t }
-
- -- freelist_t : basic internal lockfree list used to construct more user friendly list (FIFO queue to avoid putting constraints on free & alloc at the same times + it is needed for reclaim part).
-  do not ensure consistensy of data.
-  is { _Atomic(node*) head, tail; }
-
-  Atomic Queue List : See algorithm by Michael & Scott on Lock Free Queue List (aka MSList)
-
-  + freelist_push (&list, &node)
-  + freelist_pop(&list) return node
-  + freelist_pop_if(&list, ticket) return node Needs minor adaptation on _pop.
-
- -- lf_memory_core_t : basic type responsible for the centralization of the list allocation.
-  + init(lf_mc_t &, int max_thread, size_t alloc_size)
-  + clear(lf_mc_t &)
-  + lc_mc_t is {
-     atomic_uint ticket;
-     atomic_uint reg_thread;   // ==> genint instead
-     atomic_uint tab_ticket[MAX_THREAD];
-     freelist_t  free[MAX_THREAD];
-     freelist_t  to_be_reclaimed[MAX_THREAD];
-   }
-
- -- lf_memory_thread_t: specialization for the current thread
-  * lf_mt_t is { int thd_idx; lf_mc_t *global;}
-  * init(lf_mt_t &, &lf_mc_t g) is { thd_idx := atomic_add(&g.reg_tread, 1); .global := g;  }
-  * clear is ??   
-  * awake () is preparing the thread to handle operations on the list { .global.tab_ticket[.thd_idx] := atomic_add(&global.ticket, 1)+1; }
-  * sleep () is sleeping the thread so that it doesn't handle operations on the list and perform memory reclamation if needed { 
-        .global.tab_ticket[.thd_idx] := UINT_MAX;
-        min_ticket  := min(global.tab_ticket); 
-        scan the list to_be_reclaimed while node.cpt < min_ticket, 
-              pop the node from to_be_reclaimed and push it to the list free
-  lf_memory_thread_t shall be in awake state to do anything on the list.
-
-*** Bench
-
- Basic malloc / free: 9.6s 
-
- LF Node            : 10.6s
- 
- Even if LF Node ensures a correct life cycle of the node for the read, the performance is passable.
- Too much CAS:
-
- 51.40      6.13     6.13 51146587     0.00     0.00  lf_freelist_push
-
- 20.10      8.53     2.40 28143911     0.00     0.00  lf_freelist_pop
-
- 15.65     10.40     1.87   253579     0.01     0.02  lf_mempool_sleep
-
-*** Mixed API
-
- To overcome this limitation performs a mixed approache:
- - having a simple (non atomic) list of nodes to alloc quickly the nodes.
- - embedded within an atomic list of list of nodes for GC.
-
- Thread data will be:
- - FreeList is a non atomic singly linked list.
- - ToBeReclaimedList is the same
- - FreeListList is an atomic queue list of non atomic singly list.
- - CanBeReclaimedListList is an atomic queue list of non atomic singly list
-
- **** alloc() returns node:
- - Pop from FreeList a node.
- - If failure, atomic pop from FreeListList a list of list of free nodes. If success, update FreeList with the new list and pop a node from it.
- - If failure, try an atomic from the FreeListList of other threads.  If success, update FreeList with the new list and pop a node from it.
- - If failure, malloc a new pool of FreeListList (TBD: all nodes in one pass? Needs a separate list to handle final free of nodes).
- *** free(node)
- - Push node in ToBeReclaimedList
- *** GarbageCollector called on sleep:
- - Compute min_ticket for all threads
- - Atomic push of ToBeReclaimedList in CanBeReclaimedListList
- - for each thread starting from mine:
- -- Atomic pop from CanBeReclaimedListList[] if max ticket of pool of nodes < min_ticket and atomic push in FreeListList
-    max ticket of pool is the ticket of the top node of the list.
-
- ==> Should be much faster since there is much less CAS operations performed and GC is perfomed per block.
-
-** Second step: lf_list_t is a stack based list based on RCU:
-
-  _read: classic non atomic operations.
-
-  _push(list, data, lf_mt_t) is {
-    allocate new node from lf_mt_t.global.free, or malloc if nothing.
-    copy data into node
-    head := atomic_load(&list.head)
-    do
-      node->next := head
-    while !CAS(&list.head, &head, node)
-   # ABA problem shall not happen since node cannot be reused immediately
-
-  _pop(list, data, lf_mt_t) is {
-    head := atomic_load(&list.head) 
-    do { 
-       if head == NULL return NULL
-    } while !CAS(&list.head, &head, head.next)
-  
-    copy head.data into data
-    head.cpt := atomic_read(&global.ticket)
-    push node in global.to_be_reclaimed
-   }
-  _erase() TODO
-  _update() TODO
-
-**  Example / Way to use:
-
-  - init global memory handler.
-  - for each thread,
-     -- init thread memory handler XX,
-     -- ...
-     -- XX.awake()
-     -- ...
-     -- do as many stuff on any list as we want (this is hot spot).
-     -- ...
-     -- XX.sleep() # Memory can be reclaimed
-     -- XX.awake()
-    
-
-* TODO #15: Constructor / Destructor Prologue / Epilogue for Stack Exception Handling :ENHANCEMENT:
-
-Constructor (and destructor) need to use user-defined prologue / epilogue.
-This is in order to register the constructed object into a proper Stack Exception Handling so that exceptions throwing may work reliably.
-
-Proposal:
-
- M_CONSTRUCTOR_PROLOGUE(object, oplist);
- M_CONSTRUCTOR_EPILOGUE(object, oplist);
- M_DESTRUCTOR_PROLOGUE(object, oplist);
- M_DESTRUCTOR_EPILOGUE(object, oplist);
-
-Object creation will need to add all sub-objects into the stack, then unstack all to push instead the root object (which will recursively remove them).
-
-See also http://freetype.sourceforge.net/david/reliable-c.html#cseh
-
-
-
-* TODO #14: Memory allocation enhancement                       :ENHANCEMENT:
-
-Enhancement of the memory allocation scheme to find way to deal properly with advance allocators:
+Enhancement of the memory allocation scheme to find way to deal properly with advanced allocators:

 -  non-default alignment requirements for types,
 -  instance-based allocator (may need instance based variable access),
@@ -280,9 +519,11 @@ Needs some formal operator in the oplist to support it fully and an example.
  
 - EXTRA_DATA: Add an extra-data field wihtin the container. Defines the type of data.

+It is a kind of object  inheritance where the container inherits some extra data from its base.

+Duplicate with #32 which is more generic ==> Closed

-* TODO #12: Atomic shared pointer                               :ENHANCEMENT:
+* TODO #12 : New: Atomic shared pointer                         :ENHANCEMENT:

 Add an extension to the SHARED_PTR API:

@@ -299,7 +540,10 @@ No _ref or direct _init: we need to init first a normal shared_ptr then the atom

 ** _atomic_set method:

-It can be implemented by incrementing the non atomic shared pointer reference, then performs a compare_and_swap to the data of the atomic shared pointer, finally decrement and dec/free the swapped previous data of the atomic .
+It can be implemented by incrementing the non atomic shared pointer reference, 
+then performs a compare_and_swap to the data of the atomic shared pointer, 
+finally decrement and dec/free the swapped previous data of the atomic like a normal shared pointer.
+All 3 steps are safe.

 ** _set_atomic method:

@@ -353,13 +597,14 @@ Other alternative solution is to use the bit 0 to mark the pointer as being upda

 Other implementation seems to have it hard to be lock-free: cf. https://github.com/llvm-mirror/libcxx/commit/5fec82dc0db3623546038e4a86baa44f749e554f

-
-
-* TODO #5: Concurrent dictionary Container                      :ENHANCEMENT:
+* TODO #5 : New: Concurrent dictionary Container                :ENHANCEMENT:

 Implement a more efficient dictionary than lock + std dictionary for all operations when dealing with threads.
 See https://msdn.microsoft.com/en-us/library/dd287191(v=vs.110).aspx

+The best parallel algorithm is still when there is as few synchronization as possible. A concurrent dictionary will fail at this and will result in average performance at best.
+The typical best case will be in RCU context (a lot of readers, few writers), so the interface shall be compatible with such structure.
+
 ** Multiple locks within the dictionnary

 A potential implementation may be to request at initialization time the number of concurrent thread N.
@@ -380,29 +625,82 @@ See also https://github.com/simonhf/sharedhashfile
 ** Lock Free dictionnary 

 Evaluate also lock-free dictionary (easier with open addressing). 
-It needs a complete rewrite of the inner loop through. The hard part is the dynamic resizing of the internal array (see http://preshing.com/20160222/a-resizable-concurrent-map/ for a potential solution and http://www.cs.toronto.edu/~tomhart/papers/tomhart_thesis.pdf for memory reclamation techniques). See also https://www.research.ibm.com/people/m/michael/spaa-2002.pdf
-https://www.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.2017.11.22a.pdf persents different techniques used by linux kernel.
+It needs a complete rewrite of the inner loop through. The hard part is the dynamic resizing of the internal array.
+Ssee http://preshing.com/20160222/a-resizable-concurrent-map/ for a potential solution
+ and http://www.cs.toronto.edu/~tomhart/papers/tomhart_thesis.pdf for memory reclamation techniques). 
+ and https://www.research.ibm.com/people/m/michael/spaa-2002.pdf
+https://www.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.2017.11.22a.pdf presents different techniques used by linux kernel.
 It needs before lock-free list: http://www.cse.yorku.ca/~ruppert/papers/lfll.pdf http://www.cse.yorku.ca/~ruppert/Mikhail.pdf

-** Context
-
-The best parallel algorithm is still when there is as few synchronization as possible. A concurrent dictionary will fail at this and will result in average performance at best.
-The typical best case will be in RCU context (a lot of readers, few writers), so the interface shall be compatible with such structure.
-
-** Linked list 
-
-Another solution is to create a huge list of items which is:
-
-    atomically updated,
-    in reverse order of the hash (bit 0 is highest bit, Bit 63 is the lowest bit).
-
-Hash table will only give quick access to items to this list. Expanding the table won't change the order of the list (so the items will remain at the same place and always accessible by other threads) but just add sentinel in the sentinel at the right place (there won't be any reallocation of the list). Inserting will need to insert an item at the right place.
-Not sure it will really help. To analyse.
-
- Concurrent dictionary is possible now with CONCURRENT_DEF + DICT_DEF.
- But it uses a global lock for all dictionary access.
-
-** Open Addressing Indirect Table with a lock free node pool used as transaction pool.
-
 A good way maybe Open Addessing table used only for indirection and a freelist memory reclamation container for handle the entries
 (like a transaction).
+
+ Solution?
+ --------
+ 
+ Use of the concurrent pool (m-c-mempool) to allocate items.
+ The big table will only store pointers (+ part of hash in unused bits?) to such allocate items.
+ Atomic update is done by allocating a new node, update it, and atomicaly store it in the dict, putting the old one as logically deleted and to reclaim later.
+ (Other threads may still read its data so we cannot free immediatly). 
+ 
+* DONE #22: Enhanced services for SPSC Queue                    :ENHANCEMENT:
+
+Add services:
+
+** DONE _push_bulk
+Test the capacity of the queue and push as much as possible in the queue
+with one check of the atomic structure.
+
+** DONE _pop_bulk
+Test the capacity of the queue and push as much as possible in the queue
+with one check of the atomic structure.
+
+** DONE _push_force:
+
+If the capacity of the queue is full, pop one element and push it:
+push always succeed and the queue always keep the youngest element.
+
+* DONE #21: Generic Binary serialization                        :ENHANCEMENT:
+
+   Based on issue #26 of  https://github.com/P-p-H-d/mlib/issues/26
+   
+   Some kind of "binary serialization" on the model of get_str/parse_str 
+   could be possible. It would be a great feature from the application 
+   point-of-view: binary representation is more bandwidth-efficient if 
+   used on network communications.
+
+   It will be good to have import/export methods to the 
+   XML/JSON/MSGPACK/PROTOBUF/BINARY format. 
+   However, adding all of them on by one in the M*LIB containers
+   doesn't seem satisfactory. 
+
+   Instead, adding a generic interface for the serialization of data 
+   that may be customized by the user to perform the import/export of
+   objects in whatever format they want into what they want (FILE/memory/...). 
+   To simplify it, this interface could only support one kind of import/export
+   per compilation unit.
+
+* DONE #15: Prologue / Epilogue for Constructor / Destructor for error handling :ENHANCEMENT:
+  
+Constructor (and destructor) need to use user-defined prologue / epilogue.
+This is in order to register the constructed object into a proper Exception
+Handling Stack so that throwing exceptions may work reliably.
+
+Proposal:
+
+- M_CONSTRUCTOR_PROLOGUE(object, oplist);
+- M_CONSTRUCTOR_EPILOGUE(object, oplist);
+- M_DESTRUCTOR_PROLOGUE(object, oplist);
+- M_DESTRUCTOR_EPILOGUE(object, oplist);
+
+Object creation will need to add all sub-objects into the stack, 
+then unstack all to push instead the root object (which recursively remove them).
+
+See also http://freetype.sourceforge.net/david/reliable-c.html#cseh
+
+- How to handle like allocation of the object?
+- How to avoid calling the destructor multiple times? (It is needed?)
+- How the code can be factorized with RETCODE needs?
+
+
+
@@ -0,0 +1,16 @@
+#!/bin/sh
+mkdir -p /tmp/prepro-$USER
+name=/tmp/prepro-$USER/$$.c
+param1=""
+param2=""
+while test $# -gt 0 ; do
+    case $1 in
+        -c) param2="$param2 -c" ;;
+        *\.c)  param1="$param1 $1" ;;
+        *) param1="$param1 $1" ; param2="$param2 $1" ;;
+     esac
+    shift
+done
+cc $param1 -E |grep -v '^#' > ${name}      \
+    && perl -pi -e  's/\;/\;\n/g' ${name}    \
+    && cc $param2 ${name}
@@ -1,18 +1,63 @@
+# Copyright (c) 2017-2023, Patrick Pelissier
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# + Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# + Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
 CC=cc -std=c99
-CFLAGS=-Wall -W -pedantic -Wshadow -Wpointer-arith -Wcast-qual -Wstrict-prototypes -Wmissing-prototypes -Wswitch-default -Wswitch-enum -Wcast-align -Wpointer-arith -Wbad-function-cast -Wstrict-overflow=5 -Wstrict-prototypes -Winline -Wundef -Wnested-externs -Wcast-qual -Wshadow -Wunreachable-code -Wlogical-op -Wstrict-aliasing=2 -Wredundant-decls -Wold-style-definition -Wno-unused-function
+CFLAGS=-Wall -W -pedantic -Wshadow -Wpointer-arith -Wcast-qual -Wstrict-prototypes -Wmissing-prototypes -Wswitch-default -Wswitch-enum -Wcast-align -Wpointer-arith -Wbad-function-cast -Wstrict-overflow=5 -Wstrict-prototypes -Wundef -Wnested-externs -Wcast-qual -Wshadow -Wunreachable-code -Wlogical-op -Wstrict-aliasing=2 -Wredundant-decls -Wold-style-definition -Wno-unused-function -g
+GMP_DIR=
+MPFR_DIR=$(GMP_DIR)
 CPPFLAGS=-I..
-LDFLAGS=-pthread -lgmp
+LDFLAGS=-pthread
 RM=rm -f

 .SUFFIXES: .c .exe

 .c.exe:
-	$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) $< -o $@
+	$(CC) $(CFLAGS) $(CPPFLAGS) $< -o $@ `cat config` $(LDFLAGS)

-all:
+.c.o:
+	@$(MAKE) config
+	$(CC) $(CFLAGS) $(CPPFLAGS) -O2 `cat config.link` -DNDEBUG -g $< -c -o $@
+
+all: config
 	$(MAKE) `ls ex-*.c|sed -e 's/\.c/\.exe/g'`
+	if test "$(CC)" = "cc -std=c99" ; then $(MAKE) `ls ex11-*.c|sed -e 's/\.c/\.exe/g'` CC="cc -std=c11" ; fi
+	$(MAKE) exm.exe exn.exe
+
+exm.exe: exm-lib.o exm-main.o
+	$(CC) `cat config.link` -g $^ -o $@
+
+exn.exe: exn-lib.o exn-main.o
+	$(CC) `cat config.link` -g $^ -o $@
+
+config:
+	printf "#include <gmp.h>\nint main(void){mpz_t z; mpz_init(z); return 0;}\n" > config-test.c
+	$(CC) $(CFLAGS) $(CPPFLAGS) -I$(GMP_DIR)/include -L$(GMP_DIR)/lib config-test.c -lgmp -o config-test.exe $(LDFLAGS) 2> /dev/null && echo "-DHAVE_GMP=1 -DHAVE_MPFR=0 -I$(GMP_DIR)/include -L$(GMP_DIR)/lib -lgmp" > config || echo "-DHAVE_GMP=0 -DHAVE_MPFR=0 " > config
+	printf "#include <mpfr.h>\nint main(void){mpfr_t z; mpfr_init(z); return 0;}\n" > config-test.c
+	$(CC) $(CFLAGS) $(CPPFLAGS) -I$(GMP_DIR)/include -I$(MPFR_DIR)/include -L$(GMP_DIR)/lib -L$(MPFR_DIR)/lib config-test.c -lmpfr -lgmp -o config-test.exe $(LDFLAGS) 2> /dev/null && echo "-DHAVE_GMP=1 -DHAVE_MPFR=1  -I$(GMP_DIR)/include -L$(GMP_DIR)/lib -I$(MPFR_DIR)/include -L$(MPFR_DIR)/lib -lmpfr -lgmp" > config || echo "MPFR not available"
+	printf "#include <stdio.h>\nint main(void){printf(\"Ok\"); return 0;}\n" > config-test.c
+	$(CC) $(CFLAGS) $(CPPFLAGS) config-test.c -ffunction-sections -fdata-sections -Wl,--gc-sections 2> /dev/null && echo "-ffunction-sections -fdata-sections -Wl,--gc-sections" > config.link || echo "" > config.link
+	$(RM) config-test.c config-test.exe

 clean:
-	$(RM) *.exe *.s *~ *.o ./a.dat
+	$(RM) *.exe *.s *~ *.o ./a.dat config config.link


@@ -0,0 +1,68 @@
+#include <stdio.h>
+#include "m-array.h"
+#include "m-algo.h"
+
+/* Define a dynamic array of int */ 
+ARRAY_DEF(vector_int, int)
+/* Register the oplist of this dynamic array globally (using implicitely M_BASIC_OPLIST) */
+#define M_OPL_vector_int_t() ARRAY_OPLIST(vector_int)
+/* Define some standards algorithms on this dynamic array. We can reuse the prefix of the dynamic array */
+ALGO_DEF(vector_int, vector_int_t)
+
+/* Define a dynamic array of bool */ 
+ARRAY_DEF(vector_bool, bool)
+/* Register the oplist of this dynamic array globally */
+#define M_OPL_vector_bool_t() ARRAY_OPLIST(vector_bool, M_BOOL_OPLIST)
+/* Define some standards algorithms on this dynamic array. We can reuse the prefix of the dynamic array */
+ALGO_DEF(vector_bool, vector_bool_t)
+
+/* ID function */
+static bool id(bool x) { return x ; }
+
+int main(void)
+{
+  // Define, init (& later clear) myvector & tmp as vector_int_t
+  M_LET(myvector, tmp, vector_int_t) {
+    // Fill myvector with 3 int equal to 20
+    vector_int_fill_n(myvector, 3, 20);
+    // Fill tmp with 3 int equal to 33
+    vector_int_fill_n(tmp, 3, 33);
+    // Append all tmp in myvector
+    vector_int_splice(myvector, tmp);
+    // Fill tmp with 2 int equal to 10 
+    vector_int_fill_n(tmp, 2, 10);
+    // Append all tmp in myvector
+    vector_int_splice(myvector, tmp);
+    // Display the result
+    printf("myvector contains:");
+    // In C11, the for loop can be simplified as :
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L)
+    ALGO_FOR_EACH(myvector, vector_int_t, M_PRINT, " ");
+#else
+    for M_EACH(it, myvector, vector_int_t) {
+        printf(" %d", *it);
+    }
+#endif
+    printf("\n");
+  } /* End of M_LET: myvector & tmp are automaticly cleared */
+  
+  // Same thing but with booleans
+  M_LET(myvector, tmp, vector_bool_t) {
+    vector_bool_fill_n(myvector, 3, false);
+    vector_bool_fill_n(tmp, 3, true);
+    vector_bool_splice(myvector, tmp);
+    vector_bool_fill_n(tmp, 2, false);
+    vector_bool_splice(myvector, tmp);
+    printf("myvector contains:");
+    for M_EACH(it, myvector, vector_bool_t) {
+        printf(" %d", (int)*it);
+    }
+    printf("\n");
+    printf ("ALL: %d ANY: %d NONE: %d\n",
+            vector_bool_all_of_p(myvector, id),
+            vector_bool_any_of_p(myvector, id),
+            vector_bool_none_of_p(myvector, id) );
+  } /* End of M_LET: myvector & tmp are automaticly cleared */
+
+  return 0;
+}
@@ -0,0 +1,41 @@
+#include "m-dict.h"
+#include "m-array.h"
+#include "m-algo.h"
+#include "m-string.h"
+
+/* Define a dictionnary (or hash_map or unordered_map)
+ * from a string_t to int */
+DICT_DEF2(dict, string_t, int)
+/* Register the oplist of this dictionnary globally */
+#define M_OPL_dict_t() DICT_OPLIST(dict, STRING_OPLIST, M_BASIC_OPLIST)
+
+/* Define an array of integer */
+ARRAY_DEF(vector_int, int)
+/* Register the oplist of this array of integer globally */
+#define M_OPL_vector_int_t() ARRAY_OPLIST(vector_int)
+
+/* Micro macro to detect if the key string starts with the given pattern */
+#define start_with(pattern, item)                \
+  string_start_with_str_p((item).key, (pattern))
+
+/* Micro macro to get the value of a pair of (key, value) */
+#define get_value(out, item) ((out) = (item).value)
+
+int main(void)
+{
+  int s = 0;
+  // Init keys as a vector_int_t, initialize it (and prepare its destruction)
+  M_LET(keys, vector_int_t)
+  // Initialize m as a dictionnary and initialize it with the given database
+  // Initialize tmp as a dictionnary
+  M_LET( (m, (STRING_CTE("foo"), 1), (STRING_CTE("bar"), 42), (STRING_CTE("bluez"), 7), (STRING_CTE("stop"), 789) ), tmp, dict_t) {
+    /* Extract all elements of 'm' that starts with 'b' and fills tmp with it */
+    ALGO_EXTRACT(tmp, dict_t, m, dict_t, start_with, "b");
+    /* Extract the values of theses elements */
+    ALGO_TRANSFORM(keys, vector_int_t, tmp, dict_t, get_value);
+    /* Sum theses values */
+    ALGO_REDUCE(s, keys, vector_int_t, sum);
+    printf("Sum of elements starting with 'b' is: %d\n", s);
+  }
+  return 0;
+}
@@ -0,0 +1,41 @@
+#include "m-algo.h"
+#include "m-array.h"
+#include "m-string.h"
+
+/* Define an array of int */
+ARRAY_DEF(vector_int, int)
+/* Register the oplist of this array of int globally */
+#define M_OPL_vector_int_t() ARRAY_OPLIST(vector_int)
+
+/* Concat two strings by insertion a '-' within them */
+#define str_cat(s1, s2) (string_cat_str(s1, "-"), string_cat(s1, s2))
+
+int main(void)
+{
+  // Let 's' be a string_t and initialize it.
+  M_LET(s, string_t)
+  // Let 'v' be a vector of integer and initialize it.
+  M_LET( (v, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10), vector_int_t) {
+    int sum = 0, product = 0;
+    
+    // Compute the sum of theses integers.
+    // 'add' is a registered keyword, recognized by M*LIB to perform a sum.
+    ALGO_REDUCE(sum, v, vector_int_t, add);
+
+    // Compute the product of theses integers.
+    // 'mul' is a registered keyword, recognized by M*LIB to perform a product.
+    ALGO_REDUCE(product, v, vector_int_t, mul);
+
+    /* Example of reduction with a transformation of the type from int to string_t
+       By default, the result ("s") should be of the same type as the base type
+       of the container. This is not the case here, we want to transform the
+       type. As such, we add the precision of the type 'string_t' to 's'.
+       The transformation from string to integer is done by string_set_si */
+    ALGO_REDUCE( (s, string_t), v, vector_int_t, str_cat, string_set_si);
+
+    printf ("sum: %d\n"
+            "product: %d\n"
+            "dash str: %s\n", sum, product, string_get_cstr(s));
+  }
+  return 0;
+}
@@ -0,0 +1,629 @@
+/* Include M*LIB header */
+#include "m-array.h"
+#include "m-string.h"
+#include "m-tuple.h"
+
+/* Provide several examples of different types usage with array,
+   with the oplist to use for each case.
+
+   Each time it creates and initializes an array,
+   fills it with some number,
+   computes its sum,
+   and returns it.
+
+   This is done for several basic C types:
+   - integers,
+   - floats, 
+   - pointers, 
+   - structures,
+   - tuples
+*/
+
+
+
+/* Generate prototypes and inline functions
+   for basic types.
+   For integer and floats, there is no need to specify
+   an oplist. M_BASIC_OPLIST will be used.
+   For bool, M_BOOL_OPLIST will be used.
+ */
+ARRAY_DEF(r_bool, bool)
+
+/* Basic usage of the type */
+static int
+test_bool(int n)
+{
+  r_bool_t array;
+
+  r_bool_init(array);
+  for(int i = 0; i < n; i++) {
+    r_bool_push_back(array, i & 1);
+  }
+
+  int s = 0;
+  for(int i = 0; i < n; i++) {
+    s += *r_bool_get(array, i);
+  }
+  
+  r_bool_clear(array);
+
+  return s;
+}
+
+
+
+/* Same with type char */
+ARRAY_DEF(r_char, char)
+
+static int
+test_char(int n)
+{
+  r_char_t array;
+
+  r_char_init(array);
+  for(int i = 0; i < n; i++) {
+    r_char_push_back(array, i & 255);
+  }
+
+  int s = 0;
+  for(int i = 0; i < n; i++) {
+    s += *r_char_get(array, i);
+  }
+  
+  r_char_clear(array);
+
+  return s;
+}
+
+
+
+/* Same with type signed int. */
+ARRAY_DEF(r_int, signed int)
+
+static int
+test_int(int n)
+{
+  r_int_t array;
+
+  r_int_init(array);
+  for(int i = 0; i < n; i++) {
+    r_int_push_back(array, i);
+  }
+
+  int s = 0;
+  for(int i = 0; i < n; i++) {
+    s += *r_int_get(array, i);
+  }
+  
+  r_int_clear(array);
+
+  return s;
+}
+
+
+
+/* Same with type signed int.
+   But with an explicit oplist.
+   This generates exactly the same code than r_int
+*/
+ARRAY_DEF(r_int2, signed int, M_BASIC_OPLIST)
+
+static int
+test_int2(int n)
+{
+  r_int2_t array;
+
+  r_int2_init(array);
+  for(int i = 0; i < n; i++) {
+    r_int2_push_back(array, i);
+  }
+
+  int s = 0;
+  for(int i = 0; i < n; i++) {
+    s += *r_int2_get(array, i);
+  }
+  
+  r_int2_clear(array);
+
+  return s;
+}
+
+
+
+/* Same with type unsigned long long */
+ARRAY_DEF(r_ullong, unsigned long long)
+
+static int
+test_ullong(int n)
+{
+  r_ullong_t array;
+
+  r_ullong_init(array);
+  for(int i = 0; i < n; i++) {
+    r_ullong_push_back(array, i);
+  }
+
+  int s = 0;
+  for(int i = 0; i < n; i++) {
+    s += *r_ullong_get(array, i);
+  }
+  
+  r_ullong_clear(array);
+
+  return s;
+}
+
+
+
+/* Same with type float */
+ARRAY_DEF(r_float, float)
+
+static int
+test_float(int n)
+{
+  r_float_t array;
+
+  r_float_init(array);
+  for(int i = 0; i < n; i++) {
+    r_float_push_back(array, i/4.0);
+  }
+
+  float s = 0;
+  for(int i = 0; i < n; i++) {
+    s += *r_float_get(array, i);
+  }
+  
+  r_float_clear(array);
+
+  return s;
+}
+
+
+
+/* Same with type double and an explicit oplist*/
+ARRAY_DEF(r_double, double, M_BASIC_OPLIST)
+
+static int
+test_double(int n)
+{
+  r_double_t array;
+
+  r_double_init(array);
+  for(int i = 0; i < n; i++) {
+    r_double_push_back(array, i/4.0);
+  }
+
+  float s = 0;
+  for(int i = 0; i < n; i++) {
+    s += *r_double_get(array, i);
+  }
+  
+  r_double_clear(array);
+
+  return s;
+}
+
+
+
+/* Helper function strdup */
+static char *my_strdup(const char *p)
+{
+  size_t s = strlen(p);
+  char *d= malloc(s+1);
+  if(!d) abort();
+  strcpy(d, p);
+  return d;
+}
+
+/* Same with type const char *, representing a contant C string.
+   We *** need *** an explicit oplist to tell M*LIB
+   to consider the type as a constant C string.
+   The oplist to use is M_CSTR_OPLIST.
+   We could have used M_PTR_OPLIST too,
+   but in this case, we won't get proper string order or
+   string equality.
+*/
+ARRAY_DEF(r_cstring, const char *, M_CSTR_OPLIST)
+
+static int
+test_cstring(int n)
+{
+  r_cstring_t array;
+
+  r_cstring_init(array);
+  for(int i = 0; i < n; i++) {
+    char buffer[16];
+    // Create a string from the integer
+    sprintf(buffer, "%d", i);
+    // We need to make an explicit copy of the string
+    // since it is not supported by the basic type.
+    char *p = my_strdup(buffer);
+    // Push the copy in the container.
+    r_cstring_push_back(array, p);
+  }
+
+  int s = 0;
+  for(int i = 0; i < n; i++) {
+    // Get back the string
+    const char *p = *r_cstring_get(array, i);
+    // Convert it to an integer
+    int j = atoi(p);
+    s += j;
+  }
+
+  // We also need a special unalloc pass
+  // to free all constant strings we have allocated using my_strdup
+  for(int i = 0; i < n; i++) {
+    const char *p = *r_cstring_get(array, i);
+    free((void*)(uintptr_t)p);
+  }
+  
+  r_cstring_clear(array);
+
+  return s;
+}
+
+
+
+/* Same with type string_t of M*LIB, representing a dynamic string.
+   We don't need explicit oplist to tell M*LIB!
+   The oplist to use is STRING_OPLIST,
+   but it has been registered globaly, so we don't need to explicit
+   give it to array_def! */
+ARRAY_DEF(r_string, string_t)
+
+static int
+test_string(int n)
+{
+  r_string_t array;
+  string_t str;
+  
+  r_string_init(array);
+  string_init (str);
+  
+  for(int i = 0; i < n; i++) {
+    // create a string from an integer
+    string_set_si(str, i);
+    // No need to make a copy in the container!
+    r_string_push_back(array, str);
+  }
+
+  int s = 0;
+  for(int i = 0; i < n; i++) {
+    // Get back the string and convert it back to an integer
+    int j = atoi(string_get_cstr(*r_string_get(array, i)));
+    s += j;
+  }
+
+  // No need to explicit free each term of the array
+  string_clear(str);
+  r_string_clear(array);
+
+  return s;
+}
+
+
+
+/* Same with type string_t of M*LIB, representing a variable string
+   and its explicit oplist. As said above, it generates exactly the
+   same code. */
+ARRAY_DEF(r_string2, string_t, STRING_OPLIST)
+
+
+
+/* Same with type 'volatile unsigned int *'
+   The array stores pointers to another integer,
+   allocated somewhere else.
+   We need to tell M*LIB to handle the basic type
+   as pointers without caring for what the value of
+   the pointer is.
+   So here, we **need** to specify the oplist of the type
+   as M_PTR_OPLIST.
+ */
+ARRAY_DEF(r_vintptr, volatile unsigned int *, M_PTR_OPLIST)
+
+static int
+test_vintptr(int n)
+{
+  r_vintptr_t array;
+
+  // Allocate a secondary table to store the value.
+  unsigned *tab = calloc(n, sizeof(volatile unsigned int));
+  if (!tab) abort();
+  
+  r_vintptr_init(array);
+  for(int i = 0; i < n; i++) {
+    tab[i] = i*i - i;
+    // Push the pointer to this integer in the array
+    r_vintptr_push_back(array, &tab[i]);
+  }
+
+  int s = 0;
+  for(int i = 0; i < n; i++) {
+    // Get the pointer to the integer.
+    // As the basic type of the container is a pointer,
+    // and r_vintptr_get return a pointer to the basic type
+    // we need to dereference its return value to get the pointer value.
+    volatile unsigned *p = *r_vintptr_get(array, i);
+    s += *p;
+  }
+  
+  r_vintptr_clear(array);
+  free(tab);
+  
+  return s;
+}
+
+
+
+/* Same with a structure type.
+   We need to tell M*LIB to handle the basic type
+   as POD;
+   So here, we **need** to specify the oplist of the type
+   as M_POD_OPLIST.
+ */
+struct rock_me_out {
+  int n;
+  float other;
+};
+
+ARRAY_DEF(r_rockme, struct rock_me_out, M_POD_OPLIST)
+
+static int
+test_rockme(int n)
+{
+  r_rockme_t array;
+
+  r_rockme_init(array);
+  for(int i = 0; i < n; i++) {
+    struct rock_me_out rock;
+    rock.n = i*i - i;
+    rock.other = 0.0f;
+    // Push the struct in the array
+    r_rockme_push_back(array, rock);
+  }
+
+  int s = 0;
+  for(int i = 0; i < n; i++) {
+    // Get the pointer to the struct
+    struct rock_me_out *p = r_rockme_get(array, i);
+    s += p->n;
+  }
+  
+  r_rockme_clear(array);
+  
+  return s;
+}
+
+
+
+/* Same with a structure type defined with [1]:
+   We need to tell M*LIB to handle the basic type
+   as a special array;
+   So here, we **need** to specify the oplist of the type
+   as M_A1_OPLIST.
+ */
+typedef struct rock_me_in {
+  int n;
+  float other;
+} rock_me_in[1];
+
+ARRAY_DEF(r_rockme2, rock_me_in, M_A1_OPLIST)
+
+static int
+test_rockme2(int n)
+{
+  r_rockme2_t array;
+
+  r_rockme2_init(array);
+  for(int i = 0; i < n; i++) {
+    rock_me_in rock;
+    rock->n = i*i - i;
+    rock->other = 0.0f;
+    r_rockme2_push_back(array, rock);
+  }
+
+  int s = 0;
+  for(int i = 0; i < n; i++) {
+    // Get the pointer to the struct.
+    rock_me_in *p = r_rockme2_get(array, i);
+    s += (*p)->n;
+  }
+  
+  r_rockme2_clear(array);
+
+  return s;
+}
+
+
+
+/* Same with a structure type defined with [1] and a global registeration.
+   We need to tell M*LIB to handle the basic type
+   as a special array.
+
+   To do so, we register the oplist of rock_us_t by defining a macro based
+   on M_OPL_ + type name + () which expands with the oplist of the type.
+
+   Then we define the array, giving it only the type.
+   M*LIB will look at the global registered oplist of the type, we don't
+   need to give it explictly.
+
+   Global registeration makes easier code.
+   Registeration should be done when the type is defined.
+ */
+#define M_OPL_rock_me_in() M_A1_OPLIST
+
+ARRAY_DEF(r_rockme2b, rock_me_in)
+
+static int
+test_rockme2b(int n)
+{
+  r_rockme2b_t array;
+
+  r_rockme2b_init(array);
+  for(int i = 0; i < n; i++) {
+    rock_me_in rock;
+    rock->n = i*i - i;
+    rock->other = 0.0f;
+    r_rockme2b_push_back(array, rock);
+  }
+
+  int s = 0;
+  for(int i = 0; i < n; i++) {
+    // Get the pointer to the struct.
+    rock_me_in *p = r_rockme2b_get(array, i);
+    s += (*p)->n;
+  }
+  
+  r_rockme2b_clear(array);
+  
+  return s;
+}
+
+
+
+/* Same with a structure type defined as a tuple.
+
+   We first define a tuple. No need to specify the oplist as it uses basic C types
+   so M_BASIC_OPLIST is used by default.
+
+   Then we define the array, giving it the oplist definition of the tuple:
+   the macro TUPLE_OPLIST is used to build it based on the tuple name,
+   and the oplists of the tuple.
+
+   The main advantage of a tuple over a classic structure is that you get
+   free classic methods of your structure.
+ */
+TUPLE_DEF2(rock_you, (n, int), (other, float))
+
+ARRAY_DEF(r_rockme3, rock_you_t, TUPLE_OPLIST(rock_you, M_BASIC_OPLIST, M_BASIC_OPLIST))
+
+static int
+test_rockme3(int n)
+{
+  r_rockme3_t array;
+  rock_you_t  x;
+  
+  r_rockme3_init(array);
+  rock_you_init(x);
+  
+  for(int i = 0; i < n; i++) {
+    rock_you_set_n(x, i*i - i);
+    r_rockme3_push_back(array, x);
+  }
+
+  int s = 0;
+  for(int i = 0; i < n; i++) {
+    // Get the pointer to the structure containing the integer.
+    rock_you_t *p = r_rockme3_get(array, i);
+    s += (*p)->n;
+  }
+  
+  r_rockme3_clear(array);
+  rock_you_clear(x);
+  
+  return s;
+}
+
+
+
+/* Same with a structure type defined as a tuple using global registeration.
+
+   We first define a tuple. No need to specify the oplist as it uses basic C types
+   so M_BASIC_OPLIST is used.
+
+   Then we register the oplist of rock_us_t by defining a macro based
+   on M_OPL_ + type name + () which expands with the oplist of the type.
+
+   Then we define the array, giving it only the type.
+   M*LIB will look at the global registered oplist of the type, we don't
+   need to give it explictly.
+
+   Global registeration makes easier code.
+ */
+TUPLE_DEF2(rock_us, (n, int), (other, float))
+
+#define M_OPL_rock_us_t() TUPLE_OPLIST(rock_us, M_BASIC_OPLIST, M_BASIC_OPLIST)
+
+ARRAY_DEF(r_rockme4, rock_us_t)
+
+static int
+test_rockme4(int n)
+{
+  r_rockme4_t array;
+  rock_us_t  x;
+  
+  r_rockme4_init(array);
+  rock_us_init(x);
+  
+  for(int i = 0; i < n; i++) {
+    rock_us_set_n(x, i*i - i);
+    r_rockme4_push_back(array, x);
+  }
+
+  int s = 0;
+  for(int i = 0; i < n; i++) {
+    // Get the pointer to the structure containing the integer.
+    rock_us_t *p = r_rockme4_get(array, i);
+    s += (*p)->n;
+  }
+  
+  r_rockme4_clear(array);
+  rock_us_clear(x);
+  
+  return s;
+}
+
+
+int main (int argc, const char *argv[])
+{
+  int n = argc == 1 ? 10 : atoi(argv[1]);
+  int s;
+
+  s = test_bool(n);
+  printf ("S[bool] = %d\n", s);
+
+  s = test_char(n);
+  printf ("S[char] = %d\n", s);
+
+  s = test_int(n);
+  printf ("S[int] = %d\n", s);
+
+  s = test_int2(n);
+  printf ("S[int2] = %d\n", s);
+
+  s = test_ullong(n);
+  printf ("S[ullong] = %d\n", s);
+
+  s = test_float(n);
+  printf ("S[float] = %d\n", s);
+
+  s = test_double(n);
+  printf ("S[double] = %d\n", s);
+
+  s = test_cstring(n);
+  printf ("S[cstring] = %d\n", s);
+
+  s = test_string(n);
+  printf ("S[string] = %d\n", s);
+
+  s = test_vintptr(n);
+  printf ("S[vintptr] = %d\n", s);
+
+  s = test_rockme(n);
+  printf ("S[rockme] = %d\n", s);
+
+  s = test_rockme2(n);
+  printf ("S[rockme2] = %d\n", s);
+
+  s = test_rockme2b(n);
+  printf ("S[rockme2b] = %d\n", s);
+
+  s = test_rockme3(n);
+  printf ("S[rockme3] = %d\n", s);
+
+  s = test_rockme4(n);
+  printf ("S[rockme4] = %d\n", s);
+
+  exit(0);
+}
@@ -1,14 +1,14 @@
 #include <stdlib.h>
 #include "m-array.h"

-// Let's define an array of 'int' named 'int'
+// Let's define an array of 'int' named 'array_int'
 ARRAY_DEF(array_int, int)

 const int n = 100000;

 int main(void)
 {
-  // Declare and initilize the array
+  // Declare and initialize the array
  array_int_t x;
  array_int_init(x);

@@ -1,9 +1,13 @@
+#if HAVE_GMP
+
 #include <gmp.h>

 #include "m-array.h"
 #include "m-algo.h"

+/* Define an array of mpz_t */
 ARRAY_DEF(array_mpz, mpz_t, M_CLASSIC_OPLIST(mpz))
+/* Define some algorithm functions on array_mpz_t */
 ALGO_DEF(array_mpz, ARRAY_OPLIST(array_mpz, M_CLASSIC_OPLIST(mpz)))

 static inline void my_mpz_inc(mpz_t *d, const mpz_t a){
@@ -19,14 +23,22 @@ int main(void)
  mpz_init_set_ui(z, 1);
  array_mpz_t a;
  array_mpz_init(a);
+
  array_mpz_push_back(a, z);
  for(size_t i = 2 ; i < 1000; i++) {
    mpz_mul_ui(z, z, i);
    array_mpz_push_back(a, z);    
  }
-  /* z = sum (a[i]^2) */
+
+  /* Compute z = sum (a[i]^2) */
  array_mpz_map_reduce (&z, a, my_mpz_inc, my_mpz_sqr);
  gmp_printf ("Z=%Zd\n", z);
+
  array_mpz_clear(a);
  mpz_clear(z);
 }
+
+#else
+// Nothing to do
+int main(void) { return 0; }
+#endif
@@ -0,0 +1,117 @@
+#include "m-array.h"
+#include "m-string.h"
+
+/* This example show how to use complex structure with array 
+   embedding another library */
+
+/* This is a typical trivial library with its interface */
+typedef struct lib_ext_struct {
+  int id;
+  // Other data may be added
+} lib_ext_struct;
+
+/* Method to create a duplicate of the object.
+   The new object is heap allocated */
+static lib_ext_struct *lib_ext_struct_Duplicate(const lib_ext_struct *obj)
+{
+  lib_ext_struct *p = malloc(sizeof(lib_ext_struct));
+  if (!p) abort();
+  p->id = obj->id;
+  return p;
+}
+
+/* Method to delete any object */
+static void lib_ext_struct_Delete(lib_ext_struct *obj)
+{
+  free(obj);
+}
+
+/* This is the complex structure */
+typedef struct  {
+  uint32_t id;
+  string_t type;
+  lib_ext_struct* properties;
+} data_node;
+
+/* This method shall initialize the object data_node to
+   the init state.
+   It takes as first argument the object to initialize,
+   and since it takes by reference through a pointer,
+   it is compatible with 'API_2' convention for oplist */
+static void data_node_init(data_node *obj)
+{
+  obj->id = 0;
+  string_init(obj->type);
+  obj->properties = NULL;
+}
+
+/* This method shall initialize the object data_node to
+   the same state as the 'src' object (creating a copy, a duplicate) .
+   It takes as first argument the object to initialize,
+   and as second argument the source object.
+   It takes both object by reference through pointers,
+   as such it is compatible with 'API_6' convention for oplist */
+static void data_node_init_set(data_node *obj, const data_node *src)
+{
+  obj->id = src->id;
+  string_init_set(obj->type, src->type);
+  if (src->properties)
+    obj->properties = lib_ext_struct_Duplicate(src->properties);
+  else
+    obj->properties = NULL;
+}
+
+/* This method shall set the object data_node to
+   the same state as the 'src' object (creating a copy, a duplicate) .
+   THe object was already initialized.
+   It takes as first argument the object to initialize,
+   and as second argument the source object.
+   It takes both object by reference through pointers,
+   as such it is compatible with 'API_6' convention for oplist */
+static void data_node_set(data_node *obj, const data_node *src)
+{
+  obj->id = src->id;
+  string_set(obj->type, src->type);
+  if (obj->properties)
+    lib_ext_struct_Delete(obj->properties);    
+  if (src->properties)
+    obj->properties = lib_ext_struct_Duplicate(src->properties);
+  else
+    obj->properties = NULL;
+}
+
+/* This method shall clear the object data_node to
+   the cleared state (aka it shall free any resource).
+   It takes as first argument the object to initialize,
+   and since it takes by reference through a pointer,
+   it is compatible with 'API_2' convention for oplist */
+static void data_node_clear(data_node *obj)
+{
+  string_clear(obj->type);
+  if (obj->properties)
+    lib_ext_struct_Delete(obj->properties);
+}
+
+/* Create a dynamic array of 'data_node' named array_data_node_t
+   and gives the minimum oplist allowing M*LIB to handle
+   properly the object 'data_node' with the API convention
+   to respect for calling the methods.
+   The Manual defines the different supported API.
+*/
+ARRAY_DEF(/* the array prefix */ array_data_node,
+	  /* the object type */ data_node,
+	  /* the object oplist */ (INIT(API_2(data_node_init)),
+				   SET(API_6(data_node_set)),
+				   INIT_SET(API_6(data_node_init_set)),
+				   CLEAR(API_2(data_node_clear))))
+
+/* Define a global array with the created type */
+array_data_node_t global_array;
+
+int main(void)
+{
+  /* Call the created method */
+  array_data_node_init(global_array);
+  /* Do stuff... */
+  array_data_node_clear(global_array);
+}
@@ -0,0 +1,119 @@
+//
+// -- An A* pathfinder inspired by the tutorial at Red Blob Games --
+//     https://www.redblobgames.com/pathfinding/a-star/introduction.html
+// Code based on:
+//     https://github.com/glouw/ctl/blob/master/examples/astar.c
+
+#include <stdio.h>
+#include "m-array.h"
+#include "m-string.h"
+#include "m-tuple.h"
+#include "m-prioqueue.h"
+#include "m-dict.h"
+
+// Create a tuple of point, but don't use its priority field for comparison.
+TUPLE_DEF2( point, (x, int), (y, int), (priority, int, M_OPEXTEND( M_OPL_int(), CMP(0), HASH(0), EQUAL(0) ) ) )
+#define M_OPL_point_t() TUPLE_OPLIST(point, M_OPL_int(), M_OPL_int(), M_OPL_int())
+static inline int point_cmp_prio(const point_t a, const point_t b)
+{
+  return a->priority < b->priority ? -1 : a->priority > b->priority;
+}
+PRIOQUEUE_DEF(prio_point, point_t, M_OPEXTEND(M_OPL_point_t(), CMP(point_cmp_prio) ) )
+#define M_OPL_prio_point_t() PRIOQUEUE_OPLIST(prio_point, M_OPL_point_t() )
+ARRAY_DEF(array_point, point_t)
+#define M_OPL_array_point_t() ARRAY_OPLIST(array_point, M_OPL_point_t() )
+DICT_DEF2(cost_point, point_t, int)
+#define M_OPL_cost_point_t() DICT_OPLIST(cost_point, M_OPL_point_t(), M_OPL_int())
+DICT_DEF2(step_point, point_t, point_t)
+#define M_OPL_step_point_t() DICT_OPLIST(step_point, M_OPL_point_t(), M_OPL_point_t())
+
+static inline int point_index(const point_t p, int width)
+{
+  return p->x + width * p->y;
+}
+
+static inline void point_set_from(point_t p, const string_t maze, int width, const char pattern[])
+{
+  size_t s = string_search_str(maze, pattern);
+  point_emplace(p, s % width, s / width , 0);
+}
+
+static void astar(array_point_t path, const string_t maze, int width)
+{
+  M_LET(front, prio_point_t)
+    M_LET(from, step_point_t)
+    M_LET(costs, cost_point_t)
+    M_LET(start, goal, current, next, point_t)
+    {
+      point_set_from(start, maze, width, "@");
+      point_set_from(goal, maze, width, "!");
+      cost_point_set_at(costs, start, 0);
+      prio_point_push(front, start);
+      while (!prio_point_empty_p(front)) {
+        prio_point_pop(&current, front);
+        if (point_equal_p(current, goal))
+          break;
+        const struct { int x; int y; } deltas[] = {
+          { -1, +1 }, { 0, +1 }, { 1, +1 },
+          { -1,  0 }, /* ~ ~ */  { 1,  0 },
+          { -1, -1 }, { 0, -1 }, { 1, -1 },
+        };
+        for (size_t i = 0; i < 8; i++) {
+          point_emplace(next, current->x + deltas[i].x, current->y + deltas[i].y, 0);
+          if (string_get_char(maze, point_index(next, width)) != '#') {
+            int *new_cost = cost_point_get(costs, current);
+            int *cost     = cost_point_get(costs, next);
+            if (cost == NULL || *new_cost < *cost) {
+              cost_point_set_at(costs, next, *new_cost);
+              next->priority = *new_cost + abs(goal->x - next->x) + abs(goal->y - next->y);
+              prio_point_push(front, next);
+              step_point_set_at(from, next, current);
+            }
+          }
+        }
+      }     
+      point_set(current, goal);
+      while (!point_equal_p(current, start)) {
+        array_point_push_back(path, current);
+        point_set(current, *step_point_get(from, current));
+      }
+      array_point_push_back(path, start);
+    }
+}
+
+int main(void)
+{
+  M_LET( (maze, 
+          ("#########################################################################\n"
+           "#   #               #               #           #                   #   #\n"
+           "#   #   #########   #   #####   #########   #####   #####   #####   # ! #\n"
+           "#               #       #   #           #           #   #   #       #   #\n"
+           "#########   #   #########   #########   #####   #   #   #   #########   #\n"
+           "#       #   #               #           #   #   #   #   #           #   #\n"
+           "#   #   #############   #   #   #########   #####   #   #########   #   #\n"
+           "#   #               #   #   #       #           #           #       #   #\n"
+           "#   #############   #####   #####   #   #####   #########   #   #####   #\n"
+           "#           #       #   #       #   #       #           #   #           #\n"
+           "#   #####   #####   #   #####   #   #########   #   #   #   #############\n"
+           "#       #       #   #   #       #       #       #   #   #       #       #\n"
+           "#############   #   #   #   #########   #   #####   #   #####   #####   #\n"
+           "#           #   #           #       #   #       #   #       #           #\n"
+           "#   #####   #   #########   #####   #   #####   #####   #############   #\n"
+           "#   #       #           #           #       #   #   #               #   #\n"
+           "#   #   #########   #   #####   #########   #   #   #############   #   #\n"
+           "#   #           #   #   #   #   #           #               #   #       #\n"
+           "#   #########   #   #   #   #####   #########   #########   #   #########\n"
+           "#   #       #   #   #           #           #   #       #               #\n"
+           "# @ #   #####   #####   #####   #########   #####   #   #########   #   #\n"
+           "#   #                   #           #               #               #   #\n"
+           "#########################################################################\n")), string_t)
+    M_LET(path, array_point_t)
+    {
+      int width = string_search_str(maze, "\n") + 1;
+      astar(path, maze, width);
+      for M_EACH(it, path, array_point_t) {
+          string_set_char(maze, point_index(*it, width), 'x');
+        }
+      printf("%s", string_get_cstr(maze));
+    }
+}
@@ -0,0 +1,68 @@
+#include "m-bptree.h"
+#include "m-string.h"
+
+// Define a map int -> string named map_employee_id
+// The number 5 is the number of elements in a node of the B+TREE
+BPTREE_DEF2(map_employee_id, 5, int, string_t)
+// Register the oplist of this map globally.
+#define M_OPL_map_employee_id_t() BPTREE_OPLIST2(map_employee_id, M_BASIC_OPLIST, STRING_OPLIST)
+
+// Define a map string -> int named map_employee_name
+// The number 5 is the number of elements in a node of the B+TREE
+BPTREE_DEF2(map_employee_name, 5, string_t, int)
+// Register the oplist of this map globally.
+#define M_OPL_map_employee_name_t() BPTREE_OPLIST2(map_employee_name, STRING_OPLIST, M_BASIC_OPLIST)
+
+int main(void)
+{
+  map_employee_id_t Employees;
+  map_employee_id_init(Employees);
+
+  // Assign the map with some data
+  map_employee_id_set_at(Employees, 17425, STRING_CTE("Mike"));
+  map_employee_id_set_at(Employees, 7147, STRING_CTE("Tango"));
+  map_employee_id_set_at(Employees, 841, STRING_CTE("Charlie"));
+  map_employee_id_set_at(Employees, 11632, STRING_CTE("John Do"));
+  map_employee_id_set_at(Employees, 852, STRING_CTE("Peter"));
+  map_employee_id_set_at(Employees, 530, STRING_CTE("Amanda"));
+
+  // You can also emplace the structure
+  map_employee_id_emplace_val(Employees, 4258, "Elisabeth");
+
+  printf("Number of employees: %zu\n", map_employee_id_size(Employees));
+
+  // Iterate over the employee list
+  printf("\nList of employees (sorted by id):\n");
+  map_employee_id_it_t it;
+  for(map_employee_id_it(it, Employees); !map_employee_id_end_p(it); map_employee_id_next(it)) {
+    // Get a pointer to this employee from the iterator
+    const map_employee_id_itref_t *e = map_employee_id_cref(it);
+    // Print it
+    printf ("%d: %s\n", *(e->key_ptr), string_get_cstr(*(e->value_ptr)));
+  }
+
+  // Now, let's go using some macros!
+
+  // Let's create a reverse map
+  M_LET(Employees_r, map_employee_name_t) {
+
+    // Let's fill in the reverse map with each employee
+    // (using macro M_EACH)
+    for M_EACH(e, Employees, map_employee_id_t) {
+        map_employee_name_set_at(Employees_r, *(e->value_ptr), *(e->key_ptr));
+      }
+
+    // Iterate over the employee list
+    printf("\nList of employees (sorted by name):\n");
+    for M_EACH(e, Employees_r, map_employee_name_t) {
+        printf ("%d: %s\n", *(e->value_ptr), string_get_cstr(*(e->key_ptr)));
+      }
+
+    // Print
+    printf("\nElisabeth has id = %d\n", *map_employee_name_get(Employees_r, STRING_CTE("Elisabeth")));    
+  } /* Employees_r is cleared beyond this point */
+
+  // But employee is not
+  map_employee_id_clear(Employees);
+  return 0;
+}
@@ -2,7 +2,7 @@

 #include "m-buffer.h"
 #include "m-shared.h"
-#include "m-mutex.h"
+#include "m-thread.h"

 /* Global variable to stop scheduling */
 atomic_bool             continue_threading_g;
@@ -0,0 +1,41 @@
+#include "m-core.h"
+
+/* This example show how to use the M_LET_IF macro
+   that enables to construct an object and continue
+   if the construction succeeds.
+*/
+
+// Stubs defined for the example. Real code will use soundio library.
+struct SoundIo { int x; };
+struct SoundIoDevice { int x; };
+struct SoundIoOutStream { int x; };
+
+static struct SoundIo *soundio_create(void) { return (struct SoundIo *) malloc(sizeof(struct SoundIo)); }
+static void soundio_destroy(struct SoundIo *s) { free(s); }
+
+static struct SoundIoDevice *soundio_get_device(struct SoundIo *io, int def) { (void) io; (void) def; return (struct SoundIoDevice *) malloc(sizeof(struct SoundIoDevice)); }
+static void soundio_device_unref(struct SoundIoDevice *s) { free(s); }
+
+static struct SoundIoOutStream *soundio_outstream_create(struct SoundIoDevice *device) { (void) device ; return (struct SoundIoOutStream *) malloc(sizeof(struct SoundIoOutStream)); }
+static void soundio_outstream_destroy(struct SoundIoOutStream *s) { free(s); }
+
+static bool soundio_wait_events(struct SoundIo *s) { (void) s; return false; }
+// End of stubs
+
+int main(void)
+{
+  int err = 1;
+
+  /* Example of using M_LET_IF macro to simplify writing error handling code.
+     The following code creates some object, test if the object creation succeeds, register the destructor, and print an error if something went wrong
+  */
+  M_LET_IF( struct SoundIo *soundio = soundio_create(), soundio != 0 , soundio_destroy(soundio) , fprintf(stderr, "out of memory for soundio\n") )
+    M_LET_IF(struct SoundIoDevice *device = soundio_get_device(soundio, -1), device != 0, soundio_device_unref(device),  fprintf(stderr, "out of memory for device\n"))
+    M_LET_IF(struct SoundIoOutStream *outstream = soundio_outstream_create(device), outstream != 0, soundio_outstream_destroy(outstream), fprintf(stderr, "out of memory for stream\n")) {
+    err = 0;
+    bool cont = true;
+    while (cont)
+      cont = soundio_wait_events(soundio);
+  }
+  return err;
+}
@@ -5,8 +5,8 @@
 #include "m-string.h"

 // Define a dictionnary of string --> int
-// named 'str'
-DICT_DEF2(dict_str, string_t, STRING_OPLIST, int, M_DEFAULT_OPLIST)
+// named 'dict_str'
+DICT_DEF2(dict_str, string_t, STRING_OPLIST, int, M_BASIC_OPLIST)

 int main(void)
 {
@@ -1,10 +1,10 @@
 #include "m-dict.h"

 // Let's define a dictionary of 'unsigned int' --> 'char
-DICT_DEF2(dict_m32, unsigned int, M_DEFAULT_OPLIST, char, M_DEFAULT_OPLIST)
+DICT_DEF2(dict_m32, unsigned int, M_BASIC_OPLIST, char, M_BASIC_OPLIST)

 // Let's create a synonym for its oplist.
-#define M32_OPLIST DICT_OPLIST(dict_m32, M_DEFAULT_OPLIST, M_DEFAULT_OPLIST)
+#define M32_OPLIST DICT_OPLIST(dict_m32, M_BASIC_OPLIST, M_BASIC_OPLIST)

 #if 1 // Non macro version.

@@ -14,7 +14,7 @@ int main(void) {
  dict_m32_set_at (h, 5, 10);               // h[5] = 10
  char *k = dict_m32_get(h, 10);            // No 10 in h, so k == NULL
  int is_missing = (k != NULL);             // true
-  assert (is_missing);
+  assert (is_missing); (void) is_missing;
  dict_m32_erase(h, 5);                    // h is now empty
  dict_m32_it_t it;                         // iterate over all dictionnary
  for (dict_m32_it (it, h) ; !dict_m32_end_p (it); dict_m32_next(it)) {
@@ -5,7 +5,8 @@
 #include "m-dict.h"
 #include "m-string.h"

-DICT_DEF2(dict_map, char, M_DEFAULT_OPLIST, int, M_DEFAULT_OPLIST)
+// Define a dictionary (hashmap) from 'char' to 'int'
+DICT_DEF2(dict_map, char, int)
             
 int main(void)
 {
@@ -81,7 +82,7 @@ int main(void)
            }
          break;

-	case 7:
+        case 6:
          dict_map_clear(mp);
          string_clear (str);
          exit(0);
@@ -89,7 +90,7 @@ int main(void)
          
        default:
          printf("Wrong Choice\n");
+          break;
        }     
    }
 }
-    
@@ -5,14 +5,23 @@
 /* program that reads text from standard-input, 
   and prints the total number of distinct words found in the text. 
 */
+
+/* Definition of a set (hashset) of unique string_t */
 DICT_SET_DEF(dict_str, string_t, STRING_OPLIST)

 int main(void)
 {
+  // Define word as a string_t
  M_LET(word, STRING_OPLIST)
+  // Define wordcount as a set of string_t
  M_LET(wordcount, DICT_SET_OPLIST(dict_str, STRING_OPLIST)) {
-    while (string_fget_word(word, " \t\n,.!;:?", stdin))
+    // Read a word from the standard input
+    while (string_fget_word(word, " \t\n,.!;:?", stdin)) {
+      // Push this word in the set.
+      // Do nothing if it already exists.
      dict_str_push(wordcount, word);
+    }
+    // Print the number of words of the standard input.
    printf ("Words: %zu\n", dict_str_size(wordcount));
  }
 }
@@ -0,0 +1,56 @@
+#include <stdio.h>
+#include "m-dict.h"
+
+/*
+ * Provide OOR methods for OA Hashmap.
+ * See documentation for definition of OOR
+ * OOR values are represented as: 
+ * empty (0) is INT_MIN
+ * deleted (1) is INT_MIN + 1
+ * So valid range for integers are [INT_MIN+2, INT_MAX]
+ */
+static inline bool oor_equal_p(int k, char n)
+{
+  return k == INT_MIN + n;
+}
+
+static inline int  oor_set(char n)
+{
+  return INT_MIN + n;
+}
+
+/*
+ * Provide a custom hash function (optional for OA)
+ */
+static inline size_t hash(int n)
+{
+  return (size_t) n; // Identity hash!
+}
+
+/* Define an OA dictionnay which performs a hashmap between an int to an int */
+DICT_OA_DEF2(dict_oa,
+	     int, M_OPEXTEND(M_BASIC_OPLIST, OOR_EQUAL(oor_equal_p), OOR_SET(API_4(oor_set)), HASH(hash)),
+	     int, M_BASIC_OPLIST)
+
+int main(void)
+{
+  dict_oa_t d;
+  dict_oa_init(d);
+
+  for(int i = 0; i < 10; i++) {
+    dict_oa_set_at(d, i*i, 4*i);
+  }
+  dict_oa_set_at(d, 3, -17);
+  
+  printf("DICT[3] = %d\n", *dict_oa_get(d, 3));
+
+  dict_oa_it_t it;
+  printf("DICT=");
+  for(dict_oa_it(it, d); !dict_oa_end_p(it); dict_oa_next(it)) {
+    printf("%d:%d, ", dict_oa_cref(it)->key, dict_oa_cref(it)->value);
+  }
+  printf("\n");
+  
+  dict_oa_clear(d);
+  return 0;
+}
@@ -0,0 +1,64 @@
+#include <stdio.h>
+#include "m-dict.h"
+
+/*
+ * Provide OOR methods for OA Hashmap.
+ * See documentation for definition of OOR
+ * OOR values are represented as: 
+ * empty (0) is "EMPTY"
+ * deleted (1) is "DELETED"
+ */
+static const char empty_str[] = "EMPTY";
+static const char deleted_str[] = "DELETED";
+static const char *oor_table[] = { empty_str, deleted_str };
+
+static inline bool oor_equal_p(const char *k, int n)
+{
+  return k == oor_table[n];
+}
+
+static inline const char *oor_set(int n)
+{
+  return oor_table[n];
+}
+
+/*
+ * Provide a custom hash function (optional for OA)
+ */
+static inline size_t hash(const char *k)
+{
+  size_t r = 17;
+  while (*k) {
+    r = *k * 33 + r;
+    k++;
+  }
+  return r;
+}
+
+/* Define an OA dictionnay which performs a hashmap between a CSTR to an int */
+DICT_OA_DEF2(dict_oa,
+	     const char *, M_OPEXTEND(M_CSTR_OPLIST, OOR_EQUAL(oor_equal_p), OOR_SET(API_4(oor_set)), HASH(hash)),
+	     int, M_BASIC_OPLIST)
+
+int main(void)
+{
+  dict_oa_t d;
+  dict_oa_init(d);
+
+  dict_oa_set_at(d, "THIS", -17);
+  dict_oa_set_at(d, "IS", -170);
+  dict_oa_set_at(d, "AN", 7);
+  dict_oa_set_at(d, "EXAMPLE", 77);
+  
+  printf("DICT[\"AN\"] = %d\n", *dict_oa_get(d, "AN"));
+
+  dict_oa_it_t it;
+  printf("DICT=");
+  for(dict_oa_it(it, d); !dict_oa_end_p(it); dict_oa_next(it)) {
+    printf("%s:%d, ", dict_oa_cref(it)->key, dict_oa_cref(it)->value);
+  }
+  printf("\n");
+  
+  dict_oa_clear(d);
+  return 0;
+}
@@ -3,30 +3,54 @@
 #include "m-array.h"
 #include "m-dict.h"

+// Define an array of size_t
 ARRAY_DEF(array_size, size_t)
+// Register the oplist of this array globaly
 #define M_OPL_array_size_t() ARRAY_OPLIST(array_size)
+
+// Define a dictionary (hashmap) of string_t to array of size_t
 DICT_DEF2(map_pos, string_t, array_size_t)
+// Register the oplist of this dictionary (hashmap)
 #define M_OPL_map_pos_t() DICT_OPLIST(map_pos, STRING_OPLIST, ARRAY_OPLIST(array_size))

 int main(int argc, const char *argv[])
 {
-   if (argc == 2) {
+   if (argc != 2) {
+      printf("USAGE: %s filename\n", argv[0]);
+      exit(0);
+   }
+
+   // Define word as a string_t
   M_LET(word, string_t)
+   // Define positions as a map of string_t-->array of size_t
   M_LET(positions, map_pos_t) {
+      // Open the file
      FILE *f = fopen(argv[1], "rt");
-        if (!f) return 1;
+      if (!f) {
+         fprintf(stderr, "ERROR: Cannot open %s.\n", argv[1]);
+         return 1;
+      }
+
+      // While it reads some word from the file
      while (string_fget_word(word, " \t\n\r\"(),=", f)) {
-          array_size_t *array = map_pos_get_at(positions, word);
+         // Get the reference to the array of this word in the dictionnary (or create it if needed)
+         array_size_t *array = map_pos_safe_get(positions, word);
+         // Push the new offset to this word in the associated array
         array_size_push_back(*array, (size_t)ftell(f) - string_size(word));
      }
+
+      // Close the file
      fclose(f);

+      // Print the words and where they are:
      for M_EACH(pair, positions, map_pos_t) {
         string_fputs(stdout, pair->key);
-         for M_EACH(pos, pair->value, array_size_t)
+         for M_EACH(pos, pair->value, array_size_t) {
            printf(" %zu", *pos);
+         }
         printf("\n");
         }
-     }
-   }
+      } // All created objects are destroyed beyond this point
+
+   return 0;
 }
@@ -8,43 +8,54 @@
 #include "m-string.h"
 #include "m-algo.h"

-// Let's create a list of string.
+// Let's create a list of string by using the M*LIB dynamic string 'string_t'
+// The prefix used for generating functions will be 'list_string'
 LIST_DEF(list_string, string_t)

-// Let's register the oplist globally so that other m*lib macros
+// Let's register the oplist globally so that other M*LIB macros
 // can get the oplist without us giving it explictly to them.
+// An oplist is the association of operators to the provided methods
+// so that generic code can use correctly an object of such type.
+// LIST_OPLIST is a macro used to generate the oplist associated to the
+// list itself. It needs the prefix used for generating the list (aka list_string here)
+// and the oplist of the item in the list (aka the string oplist)
 #define M_OPL_list_string_t() LIST_OPLIST(list_string, STRING_OPLIST)

 // Let's define some basic algorithms over this list of string.
-ALGO_DEF(astring, M_OPL_list_string_t())
+// We reuse the prefix of the list to simplify usage, but algorithms can use separate namespace.
+ALGO_DEF(list_string, M_OPL_list_string_t())

 int main(void)
 {
-  // Let's create a variable named 'grow' which is a list of string_t
+  // Let's create a variable named 'list' which is a list of string_t
  // This variable is only defined within the associated '{' '}' block.
  // The constructor/destructor of the variable will be called within this block
  // You can also define the variable (list_string_t) and use explicitly
  // its constructor (list_string_init) / destructor (list_string_clear).
-  M_LET (grow, list_string_t)
+  M_LET (list, list_string_t)
    M_LET (tmpstr, string_t) { // And let's create also a string_t

-    // add string elements to the list
-    list_string_push_back (grow, STRING_CTE("AB"));
+    // add string elements to the list in different ways
+    // First is pushing a const string.
+    // The macro STRING_CTE creates a const string_t based on the given const char * string.
+    list_string_push_back (list, STRING_CTE("AB"));
+    // Second is creating a separate string_t and then pushing it in the list
    string_printf(tmpstr, "%d", 12);
-    list_string_push_back (grow, tmpstr);
-    list_string_push_back (grow, STRING_CTE("CD"));
+    list_string_push_back (list, tmpstr);
+    // Third is to emplace directly in the list by constructing a new string_t based on the given const char * 
+    list_string_emplace_back (list, "CD");

    // Serialize the list of string into a big string.
-    list_string_get_str (tmpstr, grow, false);
+    list_string_get_str (tmpstr, list, false);

-    // print out
-    printf("Number of elements = %zu\n", list_string_size(grow));
+    // print it
+    printf("Number of elements = %zu\n", list_string_size(list));
    printf("Final string = %s\n", string_get_cstr(tmpstr));

    // Let's iterate over each element of the list
    // using the macro for iteration over a container.
-    printf ("Using macro EACH :\n");
-    for M_EACH (item, grow, list_string_t) {
+    printf ("Using macro EACH:\n");
+    for M_EACH (item, list, list_string_t) {
        printf ("Item = ");
        string_fputs (stdout, *item);
        printf ("\n");
@@ -52,34 +63,59 @@ int main(void)

    // You can also use classic iterator:
    list_string_it_t it;
-    printf ("Using iterators :\n");
-    for(list_string_it(it, grow) ; !list_string_end_p(it) ; list_string_next(it)) {
+    printf ("Using iterators:\n");
+    for(list_string_it(it, list) ; !list_string_end_p(it) ; list_string_next(it)) {
      const string_t *item = list_string_cref (it);
      printf ("Item = ");
      string_fputs (stdout, *item);
      printf ("\n");
    }

+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L)
+    // Another way: we map each element to the M_PRINT function.
+    printf ("Using macro ALGO_FOR_EACH:");
+    ALGO_FOR_EACH(list, list_string_t, M_PRINT, "\nItem = ");
+    printf ("\n");
+#endif
+
    // Get the min and the max of the list
-    string_t *p = astring_min(grow);
+    string_t *p = list_string_min(list);
    printf ("Min string is %s\n", string_get_cstr(*p));
-    p = astring_max(grow);
+    p = list_string_max(list);
    printf ("Max string is %s\n", string_get_cstr(*p));

    // We can even sort the list.
-    astring_sort(grow);
-    for M_EACH (item, grow, list_string_t) {
+    list_string_sort(list);
+    for M_EACH (item, list, list_string_t) {
        printf ("Sort Item = %s\n", string_get_cstr(*item) );
      }
    
    // Split a string into a list.
    string_set_str(tmpstr, "HELLO;JOHN;HOW;ARE;YOU");
-    astring_split(grow, tmpstr, ';');
-    for M_EACH (item, grow, list_string_t) {
+    list_string_split(list, tmpstr, ';');
+    // Iterate over the splitted list
+    for M_EACH (item, list, list_string_t) {
        printf ("Split Item = %s\n", string_get_cstr(*item) );
      }
    
  } // Everything is cleared after this point.

+  // Let's create another list of string and init it.
+  list_string_t list;
+  list_string_init(list);
+  // Let's put some elements in it:
+  list_string_emplace_back (list, "A");
+  list_string_emplace_back (list, "B");
+  list_string_emplace_back (list, "C");
+  list_string_emplace_back (list, "D");
+  // Reverse it
+  list_string_reverse(list);
+  // Let's display the string by serializing the elements of the list:
+  printf ("List of string = ");
+  list_string_out_str(stdout, list);
+  printf ("\n");
+  // Don't forget to clear the list before leaving
+  list_string_clear(list);
+  
  return 0;
 }
@@ -24,22 +24,25 @@

 /* Define the needed data structure : */

-// Define a dictionnary of constant string --> integer
-DICT_DEF2(dict_mph, const char *, M_CSTR_OPLIST, uint32_t, M_DEFAULT_OPLIST)
-#define M_OPL_dict_mph_t() DICT_OPLIST(dict_mph, M_CSTR_OPLIST, M_DEFAULT_OPLIST)
+// Define a dictionnary of constant string --> integer and register it.
+DICT_DEF2(dict_mph, const char *, M_CSTR_OPLIST, uint32_t, M_BASIC_OPLIST)
+#define M_OPL_dict_mph_t() DICT_OPLIST(dict_mph, M_CSTR_OPLIST, M_BASIC_OPLIST)

-// Defin an array of integer
+// Define an array of integer to store the value and register it.
 ARRAY_DEF(array_value, uint32_t) // Start from 1. 0 is 'None'
 #define M_OPL_array_value_t() ARRAY_OPLIST(array_value)

-// Defin an array of integer
+// Define an array of integer to store the seed and register it.
 ARRAY_DEF(array_seed, int32_t)
 #define M_OPL_array_seed_t() ARRAY_OPLIST(array_seed)
+// Define algorithms on array_seed
 ALGO_DEF(array_seed, array_seed_t)

 // Define an array of constant string that are ordered by their size.
 ARRAY_DEF(array_cstr, const char *, M_CSTR_OPLIST)
+// Register it globally but with a custom CMP operator
 static inline int array_cstr_cmp(const array_cstr_t a, const array_cstr_t b) {
+  // We compare only the size
  size_t sa = array_cstr_size(a);
  size_t sb = array_cstr_size(b);
  return (sa > sb) ? -1 : (sa < sb);
@@ -121,7 +124,7 @@ CreateMinimalPerfectHash2(array_seed_t seed, array_value_t value,
           enought. */
        for(bool cont = true; cont ; ) {
          cont = false;
-          array_seed_clean(slots);
+          array_seed_reset(slots);
          for M_EACH(it, *b, array_cstr_t) {
              size_t s = hash(d, *it) % size;
              if (*array_value_get(value, s) != 0 || array_seed_contain_p(slots, s)){
@@ -191,7 +194,11 @@ static void
 dict_read_from_file(dict_mph_t dict, array_string_t arr, const char filename[])
 {
  FILE *f = fopen(filename, "rt");
-  if (!f) abort();
+  if (!f) {
+    fprintf(stderr, "ERROR: Cannot open %s\n", filename);
+    exit(2);
+  }
+
  uint32_t line = 1;
  M_LET(str, string_t) {
    while (!feof(f) && !ferror(f)) {
@@ -234,7 +241,9 @@ test(array_seed_t seed, array_value_t value, dict_mph_t dict)

 int main(int argc, const char *argv[])
 {
+  // Create arr as array_string_t, dict as dist_mph_t and seed as array_seed_t
  M_LET(arr, array_string_t) M_LET(dict, dict_mph_t) M_LET(seed, array_seed_t)
+    // and value as array_value_t
    M_LET(value, array_value_t) {
      const char *filename = (argc > 1) ? argv[1] :"/usr/share/dict/words";
      dict_read_from_file(dict, arr, filename);
@@ -4,6 +4,7 @@
 #include "m-array.h"
 #include "m-string.h"

+// Define an array of integer
 ARRAY_DEF(array_int, int)

 typedef struct {
@@ -25,7 +26,7 @@ static void tape_devance(tape_t tape) { if (tape->pos > 0) tape->pos--; }

 typedef struct {
  string_t code;
-  array_int_t bracket_map; // Should use map when possible.
+  array_int_t bracket_map;
 } program_t[1];

 static void program_init(program_t p, string_t text) {
@@ -47,8 +48,8 @@ static void program_init(program_t p, string_t text) {
        int left;
        array_int_pop_back(&left, leftstack);
        int right = pc;
-        *array_int_get_at (p->bracket_map, left) = right;
-        *array_int_get_at (p->bracket_map, right) = left;
+        *array_int_safe_get (p->bracket_map, left) = right;
+        *array_int_safe_get (p->bracket_map, right) = left;
      }

    pc++;
@@ -98,7 +99,11 @@ static void program_run(program_t p){

 static void read_file(string_t str, const string_t filename) {
  FILE *f = fopen(string_get_cstr(filename), "rt");
-  if (!f) abort();
+  if (!f) {
+    fprintf(stderr, "ERROR: Cannot open %s\n", string_get_cstr(filename));
+    exit(2); 
+  }
+  // Read the full FILE in the string
  string_fgets (str, f, STRING_READ_FILE);
  fclose(f);
 }
@@ -1,63 +0,0 @@
-#include <stdio.h>
-#include <gmp.h>
-
-#include "m-variant.h"
-#include "m-string.h"
-#include "m-dict.h"
-#include "m-array.h"
-
-/* Define a variant over two integers named integer_t
-   Notice than mpz_t has special init & clear functions
-   mpz_init & mpz_clear.
-   This is handle by the library.
-*/
-VARIANT_DEF2(my_integer,
-             (n, long long, M_DEFAULT_OPLIST),
-             (z, mpz_t, M_CLASSIC_OPLIST(mpz)))
-/* Define the oplist associated to this variant */
-#define MY_INTEGER_OPLIST VARIANT_OPLIST(my_integer, M_DEFAULT_OPLIST, M_CLASSIC_OPLIST(mpz))
-
-/* Define a dictionary of string --> integer named dict_my_t */
-DICT_DEF2(my_dict,
-          string_t, STRING_OPLIST,
-          my_integer_t, MY_INTEGER_OPLIST)
-/* Define the oplist associated to this dictionary */
-#define MY_DICT_OPLIST DICT_OPLIST(my_dict, STRING_OPLIST, MY_INTEGER_OPLIST)
-
-/* Define an array of such dictionary named array_my_t */
-ARRAY_DEF(my_array, my_dict_t, MY_DICT_OPLIST)
-/* Define the oplist associated to this array of dictionary of variant */
-#define MY_ARRAY_OPLIST ARRAY_OPLIST(my_array, MY_DICT_OPLIST)
-
-int main(void)
-{
-  M_LET(z, MY_INTEGER_OPLIST)         /* Define & init & clear an instance of a variant of integer */
-    M_LET(dict, MY_DICT_OPLIST)       /* Define & init & clear an instance of a dictionary of variant */
-    M_LET(array, MY_ARRAY_OPLIST)     /* Define & init & clear an intance of an array of dictionary of variant */
-    M_LET(gmp, M_CLASSIC_OPLIST(mpz)) /* M_LET allows even with non container type */
-    {
-      my_integer_set_n (z, 17LL);                // Set z as the long long 17
-      my_dict_set_at(dict, STRING_CTE("n1"), z); // Push it in the dictionary
-      mpz_set_str(gmp, "25446846874687468746874687468746874686874", 10); // Set gmp to a very long integer.
-      my_integer_set_z (z, gmp);                 // Set z as the mpz_t variable
-      my_dict_set_at(dict, STRING_CTE("n2"), z); // Push it in the dictionary
-      my_array_push_back (array, dict);          // Push the dictionary in the array
-
-      // Iterate over the array container
-      for M_EACH(item, array, MY_ARRAY_OPLIST) {
-          // Iterate over the dictionary container
-          for M_EACH(p, *item, MY_DICT_OPLIST) {
-              // Dictionary iterator are pair (key,value)
-              if (my_integer_n_p(p->value)) {
-                printf ("It is a long long, value = %lld\n",
-                        *my_integer_get_n(p->value));
-              }
-              if (my_integer_z_p(p->value)) {
-                printf ("It is a mpz_t, value =");
-                mpz_out_str(stdout, 10, *my_integer_get_z(p->value));
-                printf("\n");
-              }
-            }
-        }
-    } /* All variables are automatically cleared beyond this point */
-}
@@ -4,7 +4,7 @@
 /* Register a dynamic seed to M*LIB hash function. 
   This shall be done before any M*LIB header inclusion. */
 unsigned long long rand_seed;
-#define M_HASH_SEED rand_seed
+#define M_USE_HASH_SEED rand_seed

 #include "m-array.h"
 #include "m-dict.h"
@@ -84,8 +84,8 @@ DICT_DEF2(dict_json, string_t, STRING_OPLIST, json_t, JSON_OPLIST)
 ARRAY_DEF(array_json, json_t, JSON_OPLIST)

 VARIANT_DEF2(variant_json,
-             (boolean, bool, M_OPEXTEND(M_DEFAULT_OPLIST, OUT_STR(boolean_out_str), IN_STR(boolean_in_str M_IPTR)) ),
-             (real, float, M_OPEXTEND (M_DEFAULT_OPLIST, OUT_STR(real_out_str), IN_STR(real_in_str M_IPTR))),
+             (boolean, bool, M_OPEXTEND(M_BASIC_OPLIST, OUT_STR(boolean_out_str), IN_STR(boolean_in_str M_IPTR)) ),
+             (real, float, M_OPEXTEND (M_BASIC_OPLIST, OUT_STR(real_out_str), IN_STR(real_in_str M_IPTR))),
             (array, array_json_t, ARRAY_OPLIST(array_json, JSON_OPLIST)), 
             (dict, dict_json_t, DICT_OPLIST(dict_json, STRING_OPLIST, JSON_OPLIST)))

@@ -10,7 +10,7 @@
   order to show/test the good chaining of the structures */

 TUPLE_DEF2(symbol, (type, int), (name, string_t))
-#define M_OPL_symbol_t() TUPLE_OPLIST(symbol, M_DEFAULT_OPLIST, STRING_OPLIST)
+#define M_OPL_symbol_t() TUPLE_OPLIST(symbol, M_BASIC_OPLIST, STRING_OPLIST)

 ARRAY_DEF(symbol_list, symbol_t)
 #define M_OPL_symbol_list_t() ARRAY_OPLIST(symbol_list, M_OPL_symbol_t())
@@ -19,13 +19,13 @@ TUPLE_DEF2(record, (fields, symbol_list_t))
 #define M_OPL_record_t() TUPLE_OPLIST(record, M_OPL_symbol_list_t())

 TUPLE_DEF2(my_tuple, (name, string_t), (value, int))
-#define M_OPL_my_tuple_t() TUPLE_OPLIST(my_tuple)
+#define M_OPL_my_tuple_t() TUPLE_OPLIST(my_tuple, STRING_OPLIST, M_BASIC_OPLIST)

 ARRAY_DEF(my_list_of_tuple, my_tuple_t)
 #define M_OPL_my_list_of_tuple_t() ARRAY_OPLIST(my_list_of_tuple)

 TUPLE_DEF2(my_tuple_of_tuple, (name, string_t), (inner_tuple, my_tuple_t))
-#define M_OPL_my_tuple_of_tuple_t() TUPLE_OPLIST(my_tuple_of_tuple)
+#define M_OPL_my_tuple_of_tuple_t() TUPLE_OPLIST(my_tuple_of_tuple, STRING_OPLIST, M_OPL_my_tuple_t() )

 LIST_DEF(list_of_tuple_of_tuple, my_tuple_of_tuple_t)
 #define M_OPL_list_of_tuple_of_tuple_t() LIST_OPLIST(list_of_tuple_of_tuple, M_OPL_my_tuple_of_tuple_t() )
@@ -37,11 +37,11 @@ BUFFER_DEF(trbuff, my_triple_tuple_t, 100, BUFFER_QUEUE)
 #define M_OPL_trbuff_t() BUFFER_OPLIST(trbuff, M_OPL_my_triple_tuple_t())

 TUPLE_DEF2(my_junction, (active, bool), (buffer, trbuff_t))
-#define M_OPL_my_junction_t() TUPLE_OPLIST(my_junction, M_DEFAULT_OPLIST, M_OPL_trbuff_t())
+#define M_OPL_my_junction_t() TUPLE_OPLIST(my_junction, M_BASIC_OPLIST, M_OPL_trbuff_t())
           
 TUPLE_DEF2(mlib_point, (x, int), (y, int))
 #define M_OPL_mlib_point_t()                                            \
-  TUPLE_OPLIST(mlib_point, M_DEFAULT_OPLIST, M_DEFAULT_OPLIST)
+  TUPLE_OPLIST(mlib_point, M_BASIC_OPLIST, M_BASIC_OPLIST)

 TUPLE_DEF2(mlib_points, (first_ref, mlib_point_ptr, M_PTR_OPLIST),
           (second_ref, mlib_point_ptr, M_PTR_OPLIST),
@@ -51,6 +51,9 @@ TUPLE_DEF2(mlib_points, (first_ref, mlib_point_ptr, M_PTR_OPLIST),

 static void let2(void)
 {
+  // Initialize p1 as mlib_point_t with (4,4)
+  // and p2 as mlib_point_t with (5,5)
+  // and pair as mlib_point_t with default value
  M_LET((p1, 4, 4), (p2, 5, 5), mlib_point_t) {
    M_LET(pair, mlib_points_t) {
      pair->first_ref = p1;
@@ -68,6 +71,7 @@ static void let2(void)

 static void let(void)
 {
+  // Let's initialize all the declared types
  M_LET(s, symbol_t)
    M_LET(l, symbol_list_t)
    M_LET(r,record_t)
@@ -0,0 +1,38 @@
+#include <stdio.h>
+
+#include "m-array.h"
+#include "m-string.h"
+
+/* This example show ARRAY_DEF usage with string,
+   M_LET macro usage with complex initialization condition:
+   how to initialize a dynamic array and initialize it with the given arguments.
+   It show also the M_EACH keywork
+*/
+
+// Let's create a dynamic array of string_t and register it globaly
+// a so called std::vector<std::string> in C++
+ARRAY_DEF(vector_string, string_t)
+#define M_OPL_vector_string_t() ARRAY_OPLIST(vector_string, STRING_OPLIST)
+
+int main(void)
+{
+    // Let's define a new string named str
+    M_LET(str, string_t)
+    // Let's define msg as a vector_array_t
+    M_LET( (msg, STRING_CTE("Hello"), STRING_CTE("C"), STRING_CTE("World!"), STRING_CTE("Let's"), STRING_CTE("discover"), STRING_CTE("M*LIB!")), vector_string_t) {
+        // Iterate over all words of the array msg
+        for M_EACH(word, msg, vector_string_t) {
+            // Cat the current word into the target string
+            string_cat(str, *word);
+            // Also add a space character
+            string_push_back(str, ' ');
+        }
+        // Let's define another string and set it to a formatted value.
+        M_LET( (count, "\nTo display this it uses \"vector\" of %zu strings!", vector_string_size(msg)), string_t) {
+            string_cat(str, count);
+        }
+        // Print the result
+        printf("%s\n", string_get_cstr(str) );
+    }
+    return 0;
+}
@@ -0,0 +1,16 @@
+/*
+ * Micro example to test if M*LIB supports not using stdio.h
+ */
+#define M_USE_STDIO 0
+#define M_RAISE_FATAL(...) abort()
+#include "m-array.h"
+
+ARRAY_DEF(arr, int)
+
+int main(void) {
+    arr_t a;
+    arr_init(a);
+    arr_push_back(a, 4);
+    arr_clear(a);
+    return 0;
+}
@@ -4,6 +4,14 @@

 #include "m-rbtree.h"

+// Let's define one utility function.
+static void *xmalloc(size_t n)
+{
+  void *p = malloc (n);
+  if (!p) abort();
+  return p;
+}
+
 // Let's define a new type.
 typedef struct {
  int  key;
@@ -12,7 +20,7 @@ typedef struct {

 #define SIZE 256

-void *xmalloc(size_t n);
+// Let's define the prototypes of the methods of this new type.
 void my_type_init(my_type_t x);
 void my_type_clear(my_type_t x);
 void my_type_init_set(my_type_t x, const my_type_t y);
@@ -24,13 +32,6 @@ void my_type_out_str(FILE *f, const my_type_t x);
 bool my_type_in_str(my_type_t x, FILE *f);
 void my_type_rand(my_type_t x);

-void *xmalloc(size_t n)
-{
-  void *p = malloc (n);
-  if (!p) abort();
-  return p;
-}
-
 // Let's define its constructor
 void my_type_init(my_type_t x)
 {
@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "m-string.h"
+
+#define MAX_COLUMN 80
+
+static void format(FILE *f)
+{
+    string_t s;
+    string_init(s);
+    while (string_fgets(s, f, STRING_READ_PURE_LINE) == true)
+    {
+        size_t n = string_size(s);
+        if (n > 0 && string_get_char(s, n-1) == '\\' && n < MAX_COLUMN) {
+            string_left(s, n-1);
+            while (n < MAX_COLUMN-1) {
+                string_push_back(s, ' ');
+                n++;
+            }
+            string_push_back(s, '\\');
+        }
+        if (n >= MAX_COLUMN && string_get_char(s, n-1) == '\\') {
+            n--;
+            string_left(s, n);
+            while (n >= MAX_COLUMN-2 && string_get_char(s, n-1) == ' ') {
+                n--;
+                string_left(s, n);
+            }
+            string_push_back(s, ' ');
+            string_push_back(s, '\\');
+        }
+        printf("%s\n", string_get_cstr(s));
+    }
+    string_clear(s);
+}
+
+int main(int argc, const char *argv[])
+{
+    if (argc < 2)
+    {
+        fprintf(stderr, "ERROR: Missing argument filename.\nUSAGE: %s filename.h\n", argv[0]);
+        exit(1);
+    }
+    FILE *f = fopen(argv[1], "rt");
+    if (!f) {
+        fprintf(stderr, "ERROR: Cannot open filename '%s' .h\n", argv[1]);
+        exit(2);
+    }
+    format(f);
+    fclose(f);
+    exit(0);
+}
@@ -0,0 +1,97 @@
+#include "m-array.h"
+#include "m-string.h"
+
+// Define an array of string_t. Since the oplist of string_t is registered globaly
+// there is no need to give it to this definition.
+ARRAY_DEF(str_array, string_t)
+
+// First the verbose way and (nearly) macro free:
+static void main_macrofree(void)
+{
+    str_array_t tab_name;
+    str_array_init(tab_name);
+
+    // Push some elements in the array (long way)
+    str_array_push_back(tab_name, STRING_CTE("My"));
+    str_array_push_back(tab_name, STRING_CTE("CD"));
+    str_array_push_back(tab_name, STRING_CTE("IS"));
+    str_array_push_back(tab_name, STRING_CTE("OUT"));
+
+    // Overwrite element 1 of the array.
+    str_array_set_at(tab_name, 1, STRING_CTE("DVD"));
+
+    // Finaly rewrite 1 element of the array
+    string_set_str(*str_array_get(tab_name, 1), "BLU-RAY");
+    
+    // Format some strings and push them back in the array
+    string_t format;
+    string_init_printf(format, "There are %d elements", str_array_size(tab_name));
+    str_array_push_back(tab_name, format);
+    string_printf(format, "There is a capacty of %d", str_array_capacity(tab_name));
+    string_replace_all_str(format, "capacty", "capacity");
+    str_array_push_back(tab_name, format);
+    string_printf(format, "The third element is '%s'", string_get_cstr(*str_array_get(tab_name, 2)));
+    str_array_push_back(tab_name, format);
+    string_clear(format);
+
+    // Display the content of the array.
+    str_array_it_t it;
+    int i = 0;
+    for (str_array_it(it, tab_name) ; !str_array_end_p(it); str_array_next(it)) {
+        printf("item[%d] = '%s'\n", i, string_get_cstr(*str_array_cref(it)) );
+        i++;
+    }
+
+    // Clear the array
+    str_array_clear(tab_name);
+}
+
+// Then the short version with macros. 
+// For this we need to register the oplist of the array of string globally.
+#define M_OPL_str_array_t() ARRAY_OPLIST(str_array, STRING_OPLIST)
+
+static void main_macro(void)
+{
+    // Define and fill an array of string with some elements in it:
+    M_LET( (tab_name, STRING_CTE("My"), STRING_CTE("CD"), STRING_CTE("IS"), STRING_CTE("OUT")), str_array_t) {
+        // Overwrite element 1 of the array.
+        str_array_set_at(tab_name, 1, STRING_CTE("DVD"));
+
+        // Finaly rewrite 1 element of the array
+        string_set_str(*str_array_get(tab_name, 1), "BLU-RAY");
+    
+        // Format some strings and push them back in the array
+        M_LET(format, string_t) {
+            string_printf(format, "There are %d elements", str_array_size(tab_name));
+            str_array_push_back(tab_name, format);
+            string_printf(format, "There is a capacty of %d", str_array_capacity(tab_name));
+            string_replace_all_str(format, "capacty", "capacity");
+            str_array_push_back(tab_name, format);
+            string_printf(format, "The third element is '%s'", string_get_cstr(*str_array_get(tab_name, 2)));
+            str_array_push_back(tab_name, format);
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+            // Set format to a formated string
+            // In C11, we can mix string_t and char *.
+            // We can also use M_CSTR to create a printf formated string.
+            string_sets(format, "FILE=", getenv("PWD"), "/", *str_array_get(tab_name, 2), M_CSTR("-%zu.txt", str_array_size(tab_name) ));
+            str_array_push_back(tab_name, format);
+#endif
+        } // beyond this point format is cleared
+
+        // Display the content of the array.
+        int i = 0;
+        for M_EACH(item, tab_name, str_array_t) {
+            printf("item[%d] = '%s'\n", i, string_get_cstr(*item) );
+            i++;
+        }
+    } // beyond this point tab_name is cleared
+}
+
+int main(void)
+{
+    printf("Version macrofree:\n");
+    main_macrofree();
+    printf("Version macro:\n");
+    main_macro();
+    return 0;
+}
@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include "m-string.h"
+#include "m-dict.h"
+#include "m-array.h"
+
+/* Definition of an associative map string_t --> size_t */
+DICT_DEF2(dict_str, string_t, size_t)
+#define M_OPL_dict_str_t() DICT_OPLIST(dict_str, STRING_OPLIST, M_BASIC_OPLIST)
+
+/* Definition of an array of string_t */
+ARRAY_DEF(vector_str, string_t)
+#define M_OPL_vector_str_t() ARRAY_OPLIST(vector_str, STRING_OPLIST)
+
+int main(void)
+{
+    // Construct an array of string, performing a convertion of the C const char *
+    // into a proper string_t at real time and push then into a dynamic array
+    // that is declared, initialized and cleared.
+    M_LET( (words, ("This"), ("is"), ("a"), ("useless"), ("sentence"), ("."),
+                    ("It"), ("is"), ("used"), ("a"), ("bit"), ("to"), ("count"), ("words"), (".") ),
+                    vector_str_t) {
+        // Print the arrays.
+        printf("The words are: ");
+        vector_str_out_str(stdout, words);
+        printf("\n");
+
+        // Count the words.
+        M_LET(map, dict_str_t) {
+            // Count the words into the dictionnary 'map'
+            for M_EACH(w, words, vector_str_t) {
+                (*dict_str_safe_get(map, *w)) ++;
+            }
+
+            // Print the count:
+            for M_EACH(p, map, dict_str_t) {
+                // In C11 version we can use the M_PRINT macro that simplifies formatting.
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L)            
+                M_PRINT(p->value, " occurences of ", p->key, "\n");
+#else
+                printf ("%zu occurences of %s\n", p->value, string_get_cstr(p->key));
+#endif
+            }
+        }
+    }
+}
@@ -0,0 +1,37 @@
+/* Based on https://en.cppreference.com/w/cpp/algorithm/for_each
+   Need to be built in C11 mode */
+
+#include <stdio.h>
+#include "m-array.h"
+#include "m-algo.h"
+
+/* Define a dynamic array of int */ 
+ARRAY_DEF(vector_int, int)
+#define M_OPL_vector_int_t() ARRAY_OPLIST(vector_int)
+
+/* Define operator increment on int */
+#define INC(n) (n)++
+
+int main(void)
+{
+  M_LET( (nums, 3, 4, 2, 8, 15, 267), vector_int_t) {
+    // Print the array before
+    printf ("before:");
+    ALGO_FOR_EACH(nums, vector_int_t, M_PRINT, " ");
+    printf ("\n");
+
+    // Increment each element of the array
+    ALGO_FOR_EACH(nums, vector_int_t, INC);
+    
+    // Print the array after
+    printf ("after: ");
+    ALGO_FOR_EACH(nums, vector_int_t, M_PRINT, " ");
+    printf ("\n");
+
+    // Sum the elements of the array
+    int sum = 0;
+    ALGO_REDUCE(sum, nums, vector_int_t, add);
+    M_PRINT("sum = ", sum, "\n");
+  }
+  return 0;
+}
@@ -0,0 +1,89 @@
+#include "m-tuple.h"
+#include "m-array.h"
+#include "m-algo.h"
+#include "m-funcobj.h"
+#include "m-serial-json.h"
+#include "m-string.h"
+
+/* Define the employee class */
+TUPLE_DEF2(employee,
+           (name, string_t),
+           (age, int),
+           (idnum, int))
+/* Register globaly the employee_t oplist */
+#define M_OPL_employee_t() TUPLE_OPLIST(employee, STRING_OPLIST, M_BASIC_OPLIST, M_BASIC_OPLIST)
+
+/* Define an array of employee, register the oplist and define further algorithms on it */
+ARRAY_DEF(vector_employee, employee_t)
+#define M_OPL_vector_employee_t() ARRAY_OPLIST(vector_employee, M_OPL_employee_t())
+ALGO_DEF(vector_employee, vector_employee_t)
+
+/* Define the function object to select the sort order.
+ * It is named 'compare_by' and is an instance of the interface
+ * 'vector_employee_cmp_obj' created by ALGO_DEF.
+ */
+FUNC_OBJ_INS_DEF(compare_by /* name of the instance */,
+                 vector_employee_cmp_obj /* name of the interface */,
+                 (a, b) /* name of the input parameters of the function like object. The type are inherited from the interface. */, {
+                   /* code of the function object */
+                   if (string_equal_str_p(self->sort_field, "name"))
+                     return string_cmp(a->name, b->name);
+                   else if (string_equal_str_p(self->sort_field, "age"))
+                     return a->age < b->age ? -1 : a->age > b->age;
+                   else
+                     return a->idnum < b->idnum ? -1 : a->idnum > b->idnum;
+                 },
+                 /* Additional fields stored in the function object */
+                 (sort_field, string_t) )
+#define M_OPL_compare_by_t() FUNC_OBJ_INS_OPLIST(compare_by, STRING_OPLIST)
+
+// Let's read an array of person from the given JSON file
+static void read(vector_employee_t base, const char filename[])
+{
+  m_serial_return_code_t ret;
+
+  // Open the file
+  FILE *f = fopen(filename, "rt");
+  if (!f) {
+    // Handle errors
+    fprintf(stderr, "ERROR: Cannot open file '%s'.\n", filename);
+    exit(2);
+  }
+
+  // Initialize the JSON serializer with this file
+  M_LET( (in,f), m_serial_json_read_t)
+    // Read the JSON file and fill in 'base' with it.
+    ret = vector_employee_in_serial(base, in);
+
+  // Let's handle serialization error
+  if (ret != M_SERIAL_OK_DONE) {
+    fprintf(stderr, "ERROR: Cannot read JSON data from file '%s'.\nParsing stops at:\n", filename);
+    while (!feof(f)) { fputc(fgetc(f), stdout); }
+    fclose(f);
+    exit(2);
+  }
+
+  // Close the FILE
+  fclose(f);
+}
+
+int main(void)
+{
+  M_LET(emps, vector_employee_t) {
+    /* Code to populate database from JSON */
+    read(emps, "ex11-algo02.json");
+    
+    // Sort the database by employee ID number
+    M_LET( (cmp, STRING_CTE("idnum")), compare_by_t )
+      vector_employee_sort_fo(emps, compare_by_as_interface(cmp));
+    M_PRINT("Employees sorted by idnum are: ", (emps, vector_employee_t), "\n" );
+
+    // Sort the database by employee name
+    M_LET( (cmp, STRING_CTE("name")), compare_by_t )
+      vector_employee_sort_fo(emps, compare_by_as_interface(cmp));
+    M_PRINT("Employees sorted by name are: ", (emps, vector_employee_t), "\n" );
+
+    // End
+  }
+  return 0;
+}
@@ -0,0 +1,9 @@
+[
+    { "name": "John Doe", "age": 32, "idnum": 14528},
+    { "name": "Clint Smith", "age": 31, "idnum": 14529},
+    { "name": "Linda Cameron", "age": 20, "idnum": 14527},
+    { "name": "Cameron Carrey", "age": 25, "idnum": 14526},
+    { "name": "Marty Brown", "age": 26, "idnum": 14525},
+    { "name": "Donald Cow", "age": 45, "idnum": 14520}    
+]
+
@@ -0,0 +1,232 @@
+#include <stdio.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "m-tuple.h"
+#include "m-tree.h"
+#include "m-worker.h"
+#include "m-string.h"
+#include "m-atomic.h"
+
+
+/* Define the comparison function for atomic_uint type
+   to sort the atomic unsigned int with the biggest value first. */
+static inline int atomic_uint_cmp(const atomic_uint *a, const atomic_uint *b)
+{
+  unsigned ai = atomic_load(a), bi = atomic_load(b);
+  return ai > bi ? -1 : ai < bi;
+}
+
+/* Define the oplist for atomic_uint and register it globally.
+   This oplist extends the basic oplist by:
+   * disabling HASH for atomic as the default hash method won't work.
+   * providing the methods for CMP, INIT_SET and SET operators (with their API adaptator) */
+#define M_OPL_atomic_uint() M_OPEXTEND(M_BASIC_OPLIST, HASH(0), CMP(API_6(atomic_uint_cmp)), INIT_SET(API_2(atomic_store)), SET(API_2(atomic_store)))
+
+
+/* Define a directory as a tree where each node contains:
+   * the number of lines of the files in this directory,
+   * and the name of the directory/
+   Since we want to sort with the number of lines only, we extend the oplist of a string by disabling the compare method.
+   So first, let's define the node as a tuple of such elements:
+*/
+M_TUPLE_DEF2( dir, (nlines, atomic_uint), (name, m_string_t, M_OPEXTEND(M_STRING_OPLIST, CMP(0))))
+/* Register globally the oplist of this tuple */
+#define M_OPL_dir_t() M_TUPLE_OPLIST(dir, M_OPL_atomic_uint(), M_STRING_OPLIST)
+
+/* Define a hierarchical tree of directory.
+   Note that it will use the globally registered oplist associated to dir_t to use it */
+M_TREE_DEF(tree, dir_t)
+
+
+/* Maximum number of characters read by file */
+#define MAX_READ_BUFFER 8192
+
+/* Maximum number of directory to scan */
+#define MAX_DIRECTORY 100000
+
+
+/* Define the pool of worker threads */
+m_worker_t workers;
+
+/* Global synchronous block for all threads */
+m_worker_sync_t workers_block;
+
+/* Add a specialization of the spawn function for the scan_file function.
+   This functions takes as input an iterator of a tree (treated as a POD data),
+   and a file name */
+M_WORKER_SPAWN_DEF2(scan_file, (parent, tree_it_t, M_POD_OPLIST), (filename, m_string_t) )
+
+
+/* Add either the root node or a child to parent in function of the existence of parent */
+static tree_it_t
+add_directory(tree_it_t parent, const m_string_t dirname)
+{
+  if (tree_end_p(parent)) {
+    return tree_emplace_root( tree_tree(parent), 0, dirname);
+  } else {
+    return tree_emplace_child(parent, 0, dirname);
+  }
+}
+
+/* count the number of end of line character in the buffer */
+static unsigned
+count_eol(size_t num, const char buffer[num])
+{
+  unsigned count = 0;
+  for(size_t i = 0; i < num; i++) {
+    count += buffer[i] == '\n';
+  }
+  return count;
+}
+
+/* Test if a filename suffix ends with a C++ or C suffix */
+static bool
+is_a_c_file(const m_string_t filename)
+{
+  return (m_string_end_with_str_p(filename, ".c")
+    || m_string_end_with_str_p(filename, ".h")
+    || m_string_end_with_str_p(filename, ".cpp")
+    || m_string_end_with_str_p(filename, ".hpp"));
+}
+
+/* Scan the file and count its number of lines */
+static void
+scan_file(tree_it_t parent, m_string_t filename)
+{
+  FILE *f = fopen(m_string_get_cstr(filename), "rt");
+  if (f == NULL) {
+    fprintf(stderr, "ERROR: Cannot open %s as a text file.\n", m_string_get_cstr(filename) );
+    exit(1);
+  }
+
+  /* Read the FILE per bulk of MAX_READ_BUFFER */
+  char buffer[MAX_READ_BUFFER];
+  unsigned count = 0;
+  size_t num;
+  do {
+    num = fread (buffer, 1, MAX_READ_BUFFER, f);
+    count += count_eol(num, buffer);
+  } while (num == MAX_READ_BUFFER);
+  fclose(f);
+
+  /* Adding the number of lines to the parent directory */
+  dir_t *d = tree_ref(parent);
+  /* atomic add because the scan of files is done in parallel */
+  atomic_fetch_add( &(*d)->nlines, count );
+}
+
+/* Scan the directories recursively for all files */
+static void
+scan_directories(tree_it_t parent, const m_string_t dirname)
+{
+  tree_it_t it = add_directory(parent, dirname);
+
+  m_string_t filename;
+  m_string_init(filename);
+  DIR *dir = opendir(m_string_get_cstr(dirname));
+  if (dir == NULL) {
+    fprintf(stderr, "ERROR: Cannot open %s as a directory.\n", m_string_get_cstr(dirname) );
+    exit(1);
+  }
+
+  // Scan all entries in the directory
+  struct dirent *entry = readdir(dir);
+  while (entry) {
+    // Ignore hidden entries (including '.' and '..')
+    if (entry->d_name[0] != '.') {
+      // Construct the path to the filename by concatenating dirname, "/" and d_name
+      m_string_sets(filename, dirname, "/", entry->d_name);
+      // Get the property of this filename
+      struct stat buf;
+      int err = stat(m_string_get_cstr(filename), &buf);
+      if (err != 0) {
+        fprintf(stderr, "ERROR: Cannot stat %s\n", m_string_get_cstr(filename));
+        exit(2);
+      }
+      // Further scanning in function of the kind of entry
+      if (S_ISDIR(buf.st_mode)) {
+        scan_directories(it, filename);
+      } else if (is_a_c_file(filename)) {
+        // Spawn a scan of file to available workers or run it ourselves
+        m_worker_spawn_scan_file(workers_block, scan_file, it, filename);
+      }
+    }
+    // Next entry in the directory
+    entry = readdir(dir);
+  }
+  
+  closedir(dir);
+  m_string_clear(filename);
+}
+
+/* Consolidate all lines number to the parent directory */
+static void
+consolidate_directories(tree_t directories)
+{
+  // Scan all entries, first the children, then the parent
+  for(tree_it_t it = tree_it_post(directories) ; !tree_end_p(it) ; tree_next_post(&it) ) {
+    dir_t *parent = tree_up_ref(it);
+    dir_t *myself = tree_ref(it);
+    if (parent != NULL) {
+      // Add the child number of lines to the parent
+      atomic_fetch_add_explicit(&(*parent)->nlines, (*myself)->nlines, memory_order_relaxed);
+    }
+    // Sort the data of the children by the number of lines
+    tree_sort_child(it);
+  }
+}
+
+/* Print the consolidated results on stdout */
+static void
+print_result(tree_t directories)
+{
+  // Scan all entries, first the parent, then the children
+  for(tree_it_t it = tree_it(directories) ; !tree_end_p(it) ; tree_next(&it) ) {
+    int i, depth = tree_depth(it);
+    for(i = 0; i < depth; i++) printf("+");
+    for(     ; i < 8; i++) printf(" ");
+    const dir_t *d = tree_cref(it);
+    printf("%6u %s\n", (unsigned) (*d)->nlines, m_string_get_cstr( (*d)->name ) );
+  }
+}
+
+int main(int argc, const char *argv[])
+{
+  tree_t directories;
+  m_string_t str;
+
+  printf("Count the number of C/C++ lines of code\n");
+  if (argc < 2) {
+    fprintf(stderr, "ERROR. Usage is '%s <directory>'.\n", argv[0]);
+    exit(1);
+  }
+
+  /* Initialize the worker threads */
+  m_worker_init(workers);
+  
+  /* Init the tree, reserve for at least the number of max directory
+    and prevent any further increase of allocation:
+    this is to ensure that other threads can deref a dir safely */
+  tree_init(directories);
+  tree_reserve(directories, MAX_DIRECTORY);
+  tree_lock(directories, true);
+  m_string_init_set_cstr(str, argv[1]);
+  tree_it_t it = tree_it_end(directories);
+
+  /* Main processing */
+  m_worker_start(workers_block, workers);
+  scan_directories(it, str);
+  worker_sync(workers_block);
+  consolidate_directories(directories);
+  print_result(directories);
+
+  /* Clear everything & quit */
+  m_string_clear(str);
+  tree_clear(directories);
+  m_worker_clear(workers);
+
+  exit(0);
+}
@@ -0,0 +1,82 @@
+// Based on https://github.com/nanopb/nanopb/blob/master/examples/simple/simple.c
+#include <stdio.h>
+
+#include "m-serial-json.h"
+#include "m-tuple.h"
+#include "m-string.h"
+
+// Define a structure with one field
+TUPLE_DEF2(SimpleMessage,
+           (lucky_number, int))
+
+int main(void)
+{
+  string_t buffer;
+  m_serial_return_code_t status;
+
+  /* Let's define a string 'buffer' that will receive the JSON representation of our message*/
+  string_init(buffer);
+
+  /* Encode our message */
+  {
+    SimpleMessage_t message;
+    SimpleMessage_init(message);
+    
+    /* Create a stream that will write to our string buffer. */
+    m_serial_str_json_write_t stream;
+    m_serial_str_json_write_init(stream, buffer);
+        
+    /* Fill in the lucky number */
+    message->lucky_number = 13;
+        
+    /* Now we are ready to encode the message! */
+    status = SimpleMessage_out_serial(stream, message);
+    
+    /* Then just check for any errors.. */
+    if (status != M_SERIAL_OK_DONE)
+      {
+        printf("Encoding failed: %d\n", status);
+        return 1;
+      }
+
+    /* Clear the objets */
+    m_serial_str_json_write_clear(stream);
+    SimpleMessage_clear(message);
+  }
+  
+  /* Now we could transmit the message over network, store it in a file
+   * It is represented in a string 'buffer'
+   * but we are doing it right now.
+   */
+  
+  {
+    /* Allocate another space for the decoded message. */
+    SimpleMessage_t message;
+    SimpleMessage_init(message);
+    
+    /* Create a stream that reads from the buffer. */
+    m_serial_str_json_read_t stream;
+    m_serial_str_json_read_init(stream, string_get_cstr(buffer));
+    
+    /* Now we are ready to decode the message. */
+    status = SimpleMessage_in_serial(message, stream);
+    
+    /* Check for errors... */
+    if (status != M_SERIAL_OK_DONE)
+      {
+        printf("Decoding failed: %d\n", status);
+        return 1;
+      }
+    
+    /* Print the data contained in the message. */
+    printf("Your lucky number was %d!\n", message->lucky_number);
+
+    /* Clear the objets */
+    m_serial_str_json_read_clear(stream);
+    SimpleMessage_clear(message);
+  }
+
+  string_clear(buffer);
+  
+  return 0;
+}
@@ -0,0 +1,63 @@
+#include "m-serial-json.h"
+#include "m-tuple.h"
+#include "m-array.h"
+
+/* Basic example to show JSON serialization */
+
+// Let's define a 'person' composed of several fields.
+TUPLE_DEF2(person,
+           (surname, string_t),
+           (age, int),
+           (present, bool)
+           )
+// Register the oplist of this tuple globaly
+#define M_OPL_person_t() TUPLE_OPLIST(person, STRING_OPLIST, M_BASIC_OPLIST, M_BOOL_OPLIST )
+
+// Let's define an array of person
+ARRAY_DEF(base, person_t)
+// Register the oplist of this array globaly
+#define M_OPL_base_t() ARRAY_OPLIST(base, M_OPL_person_t())
+
+// Let's read an array of person from the given JSON file
+static void read(base_t base, const char filename[])
+{
+  m_serial_read_t  in;
+  m_serial_return_code_t ret;
+
+  // Open the file
+  FILE *f = fopen(filename, "rt");
+  if (!f) {
+    fprintf(stderr, "ERROR: Cannot open file '%s'.\n", filename);
+    exit(2);
+  }
+
+  // Initialize the serializer with the file
+  m_serial_json_read_init(in, f);
+  // Read the array
+  ret = base_in_serial(base, in);
+  if (ret != M_SERIAL_OK_DONE) {
+    fprintf(stderr, "ERROR: Cannot read JSON data from file '%s'.\n", filename);
+    exit(2);
+  }
+  // Let's close & clear all
+  m_serial_json_read_clear(in);
+  fclose(f);
+}
+
+int main(void)
+{
+  // Let's have base as a base_t
+  M_LET(base, base_t) {
+    // Read the JSON file and fill-in base
+    read(base, "ex11-json01.json");
+    base_emplace_back(base, STRING_CTE("John"), 40, false);
+    // Print the contents of base:
+    printf ("List of presents:\n");
+    for M_EACH(el, base, base_t) {
+      if ((*el)->present) {
+        printf("%s\n", string_get_cstr((*el)->surname));
+      }
+    }
+  }
+  exit(0);    
+}