V0.4.0

* Micro optimization

.github/workflows/ccpp.yml

@@ -0,0 +1,45 @@
+name: C/C++ CI
+
+on: [push]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        platform: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.platform }}
+    
+    steps:
+    - uses: actions/checkout@v1
+    - name: make
+      run: make
+    - name: make check
+      run: make check
+
+  build_windows_mingw:
+    strategy:
+      matrix:
+        platform: [windows-latest]
+    runs-on: ${{ matrix.platform }}
+    
+    steps:
+    - uses: actions/checkout@v1
+    - name:  Install MINGW
+      run:   choco install mingw --no-progress
+    - name: make check
+      shell: bash
+      run: mingw32-make CC="gcc -std=c99 -D__USE_MINGW_ANSI_STDIO=1" check
+
+  build_windows_visual:
+    strategy:
+      matrix:
+        platform: [windows-latest]
+    runs-on: ${{ matrix.platform }}
+    
+    steps:
+    - uses: actions/checkout@v1
+    - name: make check
+      shell: cmd
+      working-directory: ./tests
+      run: Make-check-cl.bat
+      

.gitignore

@@ -36,3 +36,7 @@ depend
 
 # Others
 other/
+a*.dat
+config
+fail*.log
+.vscode

LICENSE

@@ -1,6 +1,6 @@
 BSD 2-Clause License
 
-Copyright (c) 2017-2018, Patrick Pelissier
+Copyright (c) 2017-2020, Patrick Pelissier
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

Makefile

@@ -1,8 +1,26 @@
-PREFIX=/usr/local
+# Environnement variable. To customize if needed.
 RM=rm -f
 MKDIR=mkdir -p
+INSTALL=install
+INSTALL_PROGRAM=${INSTALL}
+INSTALL_DATA=${INSTALL} -m 644
 
-.PHONY: all test check doc clean distclean depend depend.png install
+# Installation directory
+PREFIX=/usr/local
+DESTDIR=
+
+# Package name & version.
+PACKAGE=m_lib-$(VERSION)
+VERSION=0.4.0
+
+# Define the contain of the distribution tarball
+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-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-tuple.h m-variant.h m-worker.h
+DOC1=LICENSE README.md
+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/ex-array00.c example/ex-array01.c example/ex-array02.c example/ex-array03.c example/ex-array04.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-json01.c example/ex-list01.c example/ex-mph.c example/ex-multi01.c example/ex-multi02.c example/ex-multi03.c example/ex-multi04.c example/ex-rbtree01.c example/ex-section.c example/Makefile
+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/wip-mregister.c tests/Makefile tests/coverage.h tests/test-obj.h tests/dict.txt
+
+.PHONY: all test check doc clean distclean depend install uninstall dist
 
 all:
 	@echo "Nothing to be done."
@@ -13,25 +31,51 @@ check:
 	cd tests && $(MAKE) check
 	cd example && $(MAKE) all
 
-doc:	README.md
+checkall:
+	cd tests && $(MAKE) checkall
+	cd example && $(MAKE) all
+
+html:	doc
+doc:	README.md doc/depend.png
 	markdown < README.md > README.html
 
 clean:
 	cd tests && $(MAKE) clean
 	cd example && $(MAKE) clean
 	cd bench && $(MAKE) clean
-	$(RM) -f README.html depend.dot
+	$(RM) README.html depend.dot
+	$(RM) -r 'm*lib-$(VERSION)'
+	$(RM) 'm*lib-$(VERSION).tar.bz2'
 
-distclean:
+distclean: clean
 	cd tests && $(MAKE) distclean
 
 depend:
 	cd tests && $(MAKE) depend
 
-depend.png:
+doc/depend.png: $(HEADER)
 	(echo "digraph g { " ; for i in *.h ; do list=$$(grep "include \"" $$i |cut -f2 -d\") ; for j in $$list ; do echo "\"$$i\" -> \"$$j\" ;" ; done ; done ; echo "}" )> depend.dot
-	dot -Tpng depend.dot -o depend.png
+	dot -Tpng depend.dot -o doc/depend.png
+	optipng -o7 doc/depend.png
+
+dist: $(HEADER) $(DOC1) $(DOC2) $(EXAMPLE) $(TEST) Makefile clean
+	$(MKDIR) '$(PACKAGE)'
+	$(MKDIR) '$(PACKAGE)/doc'
+	$(MKDIR) '$(PACKAGE)/tests'
+	$(MKDIR) '$(PACKAGE)/example'
+	cp $(HEADER) $(DOC1) Makefile '$(PACKAGE)'
+	cp $(EXAMPLE) '$(PACKAGE)/example'
+	cp $(TEST) '$(PACKAGE)/tests'
+	cp $(DOC2) '$(PACKAGE)/doc'
+	cd '$(PACKAGE)/tests' && $(MAKE) depend
+	tar jcf '$(PACKAGE).tar.bz2' '$(PACKAGE)'
+
+distcheck: dist
+	cd '$(PACKAGE)' && make check
 
 install:
 	$(MKDIR) $(DESTDIR)$(PREFIX)/include
-	cp m-*.h $(DESTDIR)$(PREFIX)/include
+	$(INSTALL_DATA) $(HEADER) $(DESTDIR)$(PREFIX)/include
+
+uninstall:
+	for i in $(HEADER) ; do $(RM) $(DESTDIR)$(PREFIX)/include/$$i ; done

bench/Makefile

@@ -1,17 +1,23 @@
 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-hopscotchmap bench-mlib-thread bench-liblfds bench-concurrentqueue bench-boost bench-mempool bench-string bench-plain
 
 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-sparsepp bench-densehashmap bench-collectionc bench-tommyds bench-flathashmap bench-emilib bench-hopscotchmap bench-uthash bench-qlibc bench-libsrt bench-nedtries bench-rigtorp-hashmap
 	@echo "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"
 
 queue: bench-mlib-thread bench-liblfds bench-concurrentqueue bench-boost
@@ -32,42 +38,56 @@ 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
 	@./bench-mlib.exe 30
+	@./bench-mlib.exe 31
 	@./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
 	@./bench-mlib-mempool.exe 30
+	@./bench-mlib-mempool.exe 31
 	@./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
@@ -76,7 +96,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 `PKG_CONFIG_PATH="$${QT}" pkg-config --libs --cflags Qt5Core` bench-qt.cpp common.c -o bench-qt.exe
 	@./bench-qt.exe 10
 	@./bench-qt.exe 20
 	@./bench-qt.exe 30
@@ -89,7 +109,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
@@ -102,7 +122,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
@@ -115,20 +135,17 @@ 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 `PKG_CONFIG_PATH="$${LIBDYNAMIC}" pkg-config --libs --cflags libdynamic` 
 	@./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
@@ -138,17 +155,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
@@ -161,7 +178,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
@@ -173,17 +190,29 @@ 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
+
 # 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
@@ -193,12 +222,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.
@@ -206,24 +234,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}/include/libsrt" bench-libsrt.c common.c -o bench-libsrt.exe $${LIBSRT}/lib/libsrt.a 
 	@./bench-libsrt.exe 20
-	@./bench-libsrt.exe 41
-	@./bench-libsrt.exe 42
-	@./bench-libsrt.exe 43
 	@./bench-libsrt.exe 50
 
 
@@ -232,7 +254,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.so -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
 
 
@@ -241,36 +263,47 @@ 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
+
 ############################################################################
 
 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
 
 ############################################################################
@@ -278,34 +311,56 @@ 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
 
 ############################################################################
 
 # BSTRLIB shall point to the BSTRLIB sources
-# LIBSRT shall point to the LIBSRT sources
+# LIBSRT shall point to the LIBSRT install directory
 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-exe BENCH_DEF="$(BENCH_DEF) -DBENCH_CAN_USE_LIBSRT -I$${LIBSRT}/src $${LIBSRT}/libsrt.a" ; else $(MAKE) bench-string-exe 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}/include/libsrt $${LIBSRT}/lib/libsrt.a" ; else $(MAKE) bench-string-step2 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)
+#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-step2:
+	@if test -n "$${SDS}" ; then $(MAKE) bench-string-step3 BENCH_DEF="$(BENCH_DEF) -fpermissive -DBENCH_CAN_USE_SDS -I$${SDS}/ $${SDS}/sds.o" ; else $(MAKE) bench-string-step3 BENCH_DEF="$(BENCH_DEF)"; fi
+
+bench-string-step3:
+	@if test -n "$${RAPIDSTRING}" ; then $(MAKE) bench-string-step4 BENCH_DEF="$(BENCH_DEF) -DBENCH_CAN_USE_RAPIDSTRING -I$${RAPIDSTRING}/ " ; else $(MAKE) bench-string-step4 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-step5:
+	$(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 3
+	@./bench-string-2.exe  2000000 4
 
+bench-string-pgo:
+	$(MAKE) bench-string XCFLAGS="-fprofile-generate=pgo"
+	$(MAKE) bench-string XCFLAGS="-fprofile-use=pgo"
 
 ############################################################################
 
 clean:
-	rm -f *.o bench-*.exe bench-*.s *~ massif.out.*
+	$(RM) *.o bench-*.exe
+	$(RM) bench-*.s *~ massif.out.*
+	$(RM) plot-*.dat
+	$(RM) pgo
 	cd nucleotide && $(MAKE) clean
 
 ############################################################################

bench/bench-boost.cpp

@@ -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);
 }
-

bench/bench-collectionc.c

@@ -93,7 +93,7 @@ static void test_rbtree(size_t n)
   stat = treetable_new(compare, &tree);
   if (stat != CC_OK) abort();
   for (size_t i = 0; i < n; i++) {
-    void *key = (void*)(uintptr_t) i;
+    void *key = (void*)(uintptr_t) rand_get();
     stat = treetable_add(tree, key, key);
     if (stat != CC_OK) abort();
   }
@@ -122,11 +122,11 @@ static int equal_func(const void *key1, const void *key2)
 {
   const unsigned long pa = (uintptr_t) key1;
   const unsigned long pb = (uintptr_t) key2;
-  return pa == pb;
+  return (pa < pb) ? -1 : pa > pb;
 }
 
 static void
-test_dict(unsigned long  n)
+test_dict(size_t  n)
 {
   HashTable *dict;
   enum cc_stat stat;
@@ -138,8 +138,8 @@ test_dict(unsigned long  n)
   if (stat != CC_OK) abort();
   
   for (size_t i = 0; i < n; i++) {
-    void *key = (void*)(uintptr_t) rand_get();
     void *value = (void*)(uintptr_t) rand_get();
+    void *key = (void*)(uintptr_t) rand_get();
     stat = hashtable_add(dict, key, value );
     if (stat != CC_OK) abort();
   }
@@ -164,7 +164,7 @@ static int char_equal (const void* a, const void * b)
 {
   const char_array_t *pa = (const char_array_t *)a;
   const char_array_t *pb = (const char_array_t *)b;
-  return strcmp(*pa,*pb)==0;
+  return strcmp(*pa,*pb);
 }
 
 static size_t char_hash(const void *a, int l, uint32_t seed)
@@ -178,7 +178,7 @@ static size_t char_hash(const void *a, int l, uint32_t seed)
 }
 
 static void
-test_dict_big(unsigned long  n)
+test_dict_big(size_t  n)
 {
   HashTable *dict;
   enum cc_stat stat;
@@ -189,9 +189,14 @@ test_dict_big(unsigned long  n)
   stat = hashtable_new_conf(&htc, &dict);
   if (stat != CC_OK) abort();
 
+  char_array_t **tab = malloc (sizeof(char_array_t *)*2*n);
+  if (!tab) abort();
+  size_t cpt = 0;
   for (size_t i = 0; i < n; i++) {
     char_array_t *key = malloc (sizeof (char_array_t));
     char_array_t *value = malloc (sizeof (char_array_t));
+    tab[cpt++] = key;
+    tab[cpt++] = value;
     sprintf(*key, "%u", rand_get());
     sprintf(*value, "%u", rand_get());
     stat = hashtable_add(dict, key, value );
@@ -209,6 +214,9 @@ test_dict_big(unsigned long  n)
   }
   g_result = s;
   hashtable_destroy(dict);
+  if (cpt != 2*n) abort();
+  for(size_t i = 0; i < 2*n;i++)
+    free(tab[i]);
 }
 
 /********************************************************************************************/
@@ -242,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);
 }

bench/bench-concurrentqueue.cpp

@@ -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);
 }
-

bench/bench-densehashmap.cpp

@@ -25,7 +25,7 @@ using namespace std;
 /********************************************************************************************/
 
 static void
-test_dict2(unsigned long  n)
+test_dict2(size_t  n)
 {
   dense_hash_map<unsigned long, unsigned long> dict;
   dict.set_empty_key(-1);
@@ -75,7 +75,7 @@ namespace std {
 }
 
 static void
-test_dict_big(unsigned long  n)
+test_dict_big(size_t  n)
 {
   dense_hash_map<char_array_s, char_array_s> dict;
   struct char_array_s empty, del;
@@ -104,7 +104,7 @@ test_dict_big(unsigned long  n)
 
 /********************************************************************************************/
 static void
-test_dict_str(unsigned long  n)
+test_dict_str(size_t  n)
 {
   dense_hash_map<string, string> dict;
   string empty, del;
@@ -131,14 +131,14 @@ test_dict_str(unsigned long  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);
 }

bench/bench-emilib.cpp

@@ -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);
+}

bench/bench-flathashmap.cpp

@@ -26,7 +26,7 @@ using namespace std;
 /********************************************************************************************/
 
 static void
-test_dict2(unsigned long  n)
+test_dict2(size_t  n)
 {
   flat_hash_map<unsigned long, unsigned long> dict;
   for (size_t i = 0; i < n; i++) {
@@ -42,6 +42,23 @@ test_dict2(unsigned long  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];
@@ -62,7 +79,7 @@ namespace std {
 }
 
 static void
-test_dict_big(unsigned long  n)
+test_dict_big(size_t  n)
 {
   flat_hash_map<char_array_s, char_array_s> dict;
 
@@ -86,7 +103,7 @@ test_dict_big(unsigned long  n)
 
 /********************************************************************************************/
 static void
-test_dict_str(unsigned long  n)
+test_dict_str(size_t  n)
 {
   flat_hash_map<string, string> dict;
 
@@ -108,14 +125,15 @@ test_dict_str(unsigned long  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);
 }

bench/bench-glib.c

@@ -97,7 +97,7 @@ static gboolean equal_func(gconstpointer a, gconstpointer b)
 }
           
 static void
-test_dict(unsigned long  n)
+test_dict(size_t  n)
 {
   GHashTable *dict = g_hash_table_new_full(hash_func, equal_func, free, free);
   for (size_t i = 0; i < n; i++) {
@@ -140,7 +140,7 @@ static guint char_hash(gconstpointer a)
 }
 
 static void
-test_dict_big(unsigned long  n)
+test_dict_big(size_t n)
 {
   GHashTable *dict = g_hash_table_new_full(char_hash, char_equal, free, free); 
   for (size_t i = 0; i < n; i++) {
@@ -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);
 }

bench/bench-hopscotchmap.cpp

@@ -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;
@@ -25,7 +25,7 @@ using namespace std;
 /********************************************************************************************/
 
 static void
-test_dict2(unsigned long  n)
+test_dict2(size_t  n)
 {
   tsl::hopscotch_map<unsigned long, unsigned long> dict;
 
@@ -63,7 +63,7 @@ namespace std {
 }
 
 static void
-test_dict_big(unsigned long  n)
+test_dict_big(size_t  n)
 {
   hopscotch_map<char_array_s, char_array_s> dict;
 
@@ -87,7 +87,7 @@ test_dict_big(unsigned long  n)
 
 /********************************************************************************************/
 static void
-test_dict_str(unsigned long  n)
+test_dict_str(size_t  n)
 {
   hopscotch_map<string, string> dict;
 
@@ -109,14 +109,15 @@ test_dict_str(unsigned long  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);
+
 }

bench/bench-klib.c

@@ -82,7 +82,7 @@ static void test_rbtree(size_t n)
   rand_init();
   unsigned int s = 0;
   for (size_t i = 0; i < n; i++) {
-    unsigned long j = 0;
+    unsigned long j = rand_get();
     if (kb_getp(kTree, tree, &j) != 0)
       s+= j;
   }
@@ -98,7 +98,7 @@ static void test_rbtree(size_t n)
 KHASH_INIT(iun, unsigned long, unsigned long, 1, hash_func, hash_eq)
 
 static void
-test_dict(unsigned long  n)
+test_dict(size_t  n)
 {
   khash_t(iun) *dict = kh_init(iun);
   
@@ -137,7 +137,7 @@ static inline size_t char_hash(const char_array_t a) {
 KHASH_INIT(iub, char_array_t, char_array_t, 1, char_hash, char_equal_p)
 
 static void
-test_dict_big(unsigned long  n)
+test_dict_big(size_t  n)
 {
   khash_t(iub) *dict = kh_init(iub);
 
@@ -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("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("KLIB", numberof(table), table, argc, argv);
   exit(0);
 }
 

bench/bench-libdynamic.c

@@ -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;
-  const unsigned long *pb = b;
-  *pa = *pb;
+  if (b == NULL) {
+    *pa = -1U;
+  } else {
+    const unsigned long *pb = b;
+    *pa = *pb;
+  }
 }
 
 typedef struct map_element map_element;
@@ -64,13 +74,13 @@ struct map_element
 };
 
 static void
-test_dict(unsigned long  n)
+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;
-  const char_array_t *pb = (const char_array_t *)b;
-  strcpy(*pa,*pb);
+  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;
@@ -115,19 +131,16 @@ struct big_map_element
 };
 
 static void
-test_dict_big(unsigned long  n)
+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(unsigned long  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);
  }

bench/bench-liblfds.c

@@ -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);
-      j = (uintptr_t)p;
-    } while (rv == 0);
+    void *p;
+    while (0 == lfds711_queue_bmm_dequeue(&g_final, &p, NULL)) {  m_thread_yield(); }
+    j = (uintptr_t)p;
     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);
-      j = (uintptr_t) p;
-    } while (rv == 0);
+    void *p;
+    while (0 == lfds711_queue_bmm_dequeue(&g_buff, &p, NULL)) {  m_thread_yield(); }
+    j = (uintptr_t) p;
     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);
 }
-

bench/bench-libsrt.c

@@ -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);
 }
 

bench/bench-mlib.c

@@ -7,12 +7,15 @@
 #include "m-array.h"
 #include "m-list.h"
 #include "m-rbtree.h"
+#include "m-bptree.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-deque.h"
+#include "m-concurrent.h"
 
 #include "common.h"
 
@@ -68,6 +71,37 @@ static void test_list (size_t n)
 
 /********************************************************************************************/
 
+// Two benched mode: with or without mempool
+#ifdef USE_MEMPOOL
+LIST_DUAL_PUSH_DEF(dlist_uint, unsigned int, (MEMPOOL( dlist_mpool), MEMPOOL_LINKAGE(static)))
+#else
+LIST_DUAL_PUSH_DEF(dlist_uint, unsigned int)
+#endif
+
+static void test_dlist (size_t n)
+{
+#ifdef USE_MEMPOOL
+  dlist_uint_mempool_init(dlist_mpool);
+#endif
+  M_LET(a1, a2, LIST_OPLIST(dlist_uint)) {
+    for(size_t i = 0; i < n; i++) {
+      dlist_uint_push_back(a1, rand_get() );
+      dlist_uint_push_back(a2, rand_get() );
+    }
+    unsigned int s = 0;
+    dlist_uint_it_t it1, it2;
+    for(dlist_uint_it(it1, a1), dlist_uint_it(it2,a2); !dlist_uint_end_p(it1); dlist_uint_next(it1), dlist_uint_next(it2)) {
+      s += *dlist_uint_cref(it1) * *dlist_uint_cref(it2);
+    }
+    g_result = s;
+  }
+#ifdef USE_MEMPOOL
+  dlist_uint_mempool_clear(dlist_mpool);
+#endif
+}
+
+/********************************************************************************************/
+
 #ifdef USE_MEMPOOL
 RBTREE_DEF(rbtree_ulong, unsigned long, (MEMPOOL( rbtree_mpool), MEMPOOL_LINKAGE(static)))
 #else
@@ -99,6 +133,27 @@ static void test_rbtree(size_t n)
 
 /********************************************************************************************/
 
+BPTREE_DEF(bptree_ulong, 21, unsigned long, M_DEFAULT_OPLIST)
+
+static void test_bptree(size_t n)
+{
+  M_LET(tree, BPTREE_OPLIST(bptree_ulong)) {
+      for (size_t i = 0; i < n; i++) {
+        bptree_ulong_push(tree, rand_get());
+      }
+      rand_init();
+      unsigned int s = 0;
+      for (size_t i = 0; i < n; i++) {
+        unsigned long *p = bptree_ulong_get(tree, rand_get());
+        if (p)
+          s += *p;
+      }
+      g_result = s;
+  }
+}
+
+/********************************************************************************************/
+
 #ifdef USE_MEMPOOL
 DICT_DEF2(dict_ulong, unsigned long, M_OPEXTEND(M_DEFAULT_OPLIST, MEMPOOL(dict_mpool), MEMPOOL_LINKAGE(static)), unsigned long, M_DEFAULT_OPLIST)
 #else
@@ -106,15 +161,16 @@ DICT_DEF2(dict_ulong, unsigned long, M_DEFAULT_OPLIST, unsigned long, M_DEFAULT_
 #endif
 
 static void
-test_dict(unsigned long  n)
+test_dict(size_t  n)
 {
 #ifdef USE_MEMPOOL
   dict_ulong_list_pair_mempool_init(dict_mpool);
 #endif
   M_LET(dict, DICT_OPLIST(dict_ulong)) {
     for (size_t i = 0; i < n; i++) {
+      unsigned long value = rand_get();
       unsigned long key = rand_get();
-      dict_ulong_set_at(dict, key, rand_get() );
+      dict_ulong_set_at(dict, key, value);
     }
     rand_init();
     unsigned int s = 0;
@@ -147,7 +203,7 @@ DICT_OA_DEF2(dict_oa_ulong,
 	     unsigned long, M_DEFAULT_OPLIST)
 
 static void
-test_dict_oa(unsigned long  n)
+test_dict_oa(size_t  n)
 {
   M_LET(dict, DICT_OPLIST(dict_oa_ulong)) {
     for (size_t i = 0; i < n; i++) {
@@ -164,26 +220,46 @@ test_dict_oa(unsigned long  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)); }
-
-// NOTE: Can't use the name OPLIST as a macro!
-#define CHAR_OPLIST (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(CHAR_OPLIST,MEMPOOL(dict_mpool2), MEMPOOL_LINKAGE(static)), char_array_t, CHAR_OPLIST)
+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())
 #else
-DICT_STOREHASH_DEF2(dict_char, char_array_t, CHAR_OPLIST, char_array_t, CHAR_OPLIST)
+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(unsigned long  n)
+test_dict_big(size_t  n)
 {
 #ifdef USE_MEMPOOL
   dict_char_list_pair_mempool_init(dict_mpool2);
@@ -211,6 +287,31 @@ test_dict_big(unsigned long  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
@@ -220,7 +321,7 @@ DICT_DEF2(dict_str, string_t, STRING_OPLIST, string_t, STRING_OPLIST)
 #endif
 
 static void
-test_dict_str(unsigned long  n)
+test_dict_str(size_t  n)
 {
 #ifdef USE_MEMPOOL
   dict_str_list_pair_mempool_init(dict_mpool3);
@@ -276,73 +377,76 @@ static void test_stable_sort(size_t n)
 
 /********************************************************************************************/
 
+#define SIZE_LIMIT (UINT_MAX/2)
+
 BUFFER_DEF(buffer_uint, unsigned int, 0, BUFFER_QUEUE|BUFFER_BLOCKING)
-buffer_uint_t g_buff;
+buffer_uint_t g_buff_lock;
 
 BUFFER_DEF(buffer_ull, unsigned long long, 0, BUFFER_QUEUE|BUFFER_BLOCKING)
-buffer_ull_t g_final;
+buffer_ull_t g_final_lock;
 
-static void final(void *arg)
+static void final_lock(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++) {
-    buffer_ull_pop(&j, g_final);
+    buffer_ull_pop(&j, g_final_lock);
     s += j;
   }
   g_result = s;
 }
 
-static void conso(void *arg)
+static void conso_lock(void *arg)
 {
   unsigned int j;
   size_t *p_n = arg;
   size_t n = *p_n;
   unsigned long long s = 0;
   for(int i = 0; i < n;i++) {
-    buffer_uint_pop(&j, g_buff);
+    buffer_uint_pop(&j, g_buff_lock);
     s += j;
   }
-  buffer_ull_push(g_final, s);
+  buffer_ull_push(g_final_lock, s);
 }
 
-static void prod(void *arg)
+static void prod_lock(void *arg)
 {
   size_t *p_n = arg;
   size_t n = *p_n;
   size_t r = n;
   for(unsigned int i = 0; i < n;i++) {
-    buffer_uint_push(g_buff, r );
+    buffer_uint_push(g_buff_lock, r );
     r = r * 31421U + 6927U;
   }
 }
 
 static void test_buffer(size_t n)
 {
-  const int cpu_count   = get_cpu_count();
+  const int cpu_count   = n > SIZE_LIMIT ? 2 : 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;
   }
+  n = n > SIZE_LIMIT ? n - SIZE_LIMIT : n;
   // Init
-  buffer_uint_init(g_buff, 64*cpu_count);
-  buffer_ull_init (g_final, 64*cpu_count);
+  buffer_uint_init(g_buff_lock, 64*cpu_count);
+  buffer_ull_init (g_final_lock, 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, &n);
+    m_thread_create (idx_p[i], prod_lock, &n);
   }
   for(int i = 0; i < conso_count; i++) {
-    m_thread_create (idx_c[i], conso, &n);
+    m_thread_create (idx_c[i], conso_lock, &n);
   }
   size_t n2 = conso_count;
-  m_thread_create(idx_final, final, &n2);
+  m_thread_create(idx_final, final_lock, &n2);
 
   // Wait for jobs to be done.
   for(int i = 0; i < prod_count; i++) {
@@ -354,79 +458,80 @@ static void test_buffer(size_t n)
   m_thread_join(idx_final);
 
   // Clear & quit
-  buffer_ull_clear(g_final);
-  buffer_uint_clear(g_buff);
+  buffer_ull_clear(g_final_lock);
+  buffer_uint_clear(g_buff_lock);
 }
 
 /********************************************************************************************/
 
 QUEUE_MPMC_DEF(queue_uint, unsigned int, BUFFER_QUEUE)
-queue_uint_t g_buff2;
+queue_uint_t g_buff_mpmc;
 
 QUEUE_MPMC_DEF(queue_ull, unsigned long long, BUFFER_QUEUE)
-queue_ull_t g_final2;
+queue_ull_t g_final_mpmc;
 
-static void final2(void *arg)
+static void final_mpmc(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_ull_pop(&j, g_final2));
+    while (!queue_ull_pop(&j, g_final_mpmc)) m_thread_yield();
     s += j;
   }
   g_result = s;
 }
 
-static void conso2(void *arg)
+static void conso_mpmc(void *arg)
 {
   unsigned int j;
   size_t *p_n = arg;
   size_t n = *p_n;
   unsigned long long s = 0;
   for(int i = 0; i < n;i++) {
-    while (!queue_uint_pop(&j, g_buff2));
+    while (!queue_uint_pop(&j, g_buff_mpmc)) m_thread_yield();
     s += j;
   }
-  while (!queue_ull_push(g_final2, s));
+  while (!queue_ull_push(g_final_mpmc, s));
 }
 
-static void prod2(void *arg)
+static void prod_mpmc(void *arg)
 {
   size_t *p_n = arg;
   size_t n = *p_n;
   size_t r = n;
   for(unsigned int i = 0; i < n;i++) {
-    while (!queue_uint_push(g_buff2, r ));
+    while (!queue_uint_push(g_buff_mpmc, r )) m_thread_yield();
     r = r * 31421U + 6927U;
   }
 }
 
 static void test_queue(size_t n)
 {
-  const int cpu_count   = get_cpu_count();
+  const int cpu_count   = n > SIZE_LIMIT ? 2 : 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 Queue performance.\n");
     return;
   }
+  n = n > SIZE_LIMIT ? n - SIZE_LIMIT : n;
   // Init
-  queue_uint_init(g_buff2, 64*cpu_count);
-  queue_ull_init (g_final2, 64*cpu_count);
+  queue_uint_init(g_buff_mpmc, 64*cpu_count);
+  queue_ull_init (g_final_mpmc, 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], prod2, &n);
+    m_thread_create (idx_p[i], prod_mpmc, &n);
   }
   for(int i = 0; i < conso_count; i++) {
-    m_thread_create (idx_c[i], conso2, &n);
+    m_thread_create (idx_c[i], conso_mpmc, &n);
   }
   size_t n2 = conso_count;
-  m_thread_create(idx_final, final2, &n2);
+  m_thread_create(idx_final, final_mpmc, &n2);
 
   // Wait for jobs to be done.
   for(int i = 0; i < prod_count; i++) {
@@ -438,8 +543,266 @@ static void test_queue(size_t n)
   m_thread_join(idx_final);
 
   // Clear & quit
-  queue_ull_clear(g_final2);
-  queue_uint_clear(g_buff2);
+  queue_ull_clear(g_final_mpmc);
+  queue_uint_clear(g_buff_mpmc);
+}
+
+/********************************************************************************************/
+
+QUEUE_SPSC_DEF(queue_single_uint, unsigned int, BUFFER_QUEUE)
+queue_single_uint_t g_buff_spsc;
+
+QUEUE_SPSC_DEF(queue_single_ull, unsigned long long, BUFFER_QUEUE)
+queue_single_ull_t g_final_spsc;
+
+static void final_spsc(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(void *arg)
+{
+  unsigned int j;
+  size_t *p_n = 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)) m_thread_yield();
+    s += j;
+  }
+  while (!queue_single_ull_push(g_final_spsc, s));
+}
+
+static void prod_spsc(void *arg)
+{
+  size_t *p_n = 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 )) m_thread_yield();
+    r = r * 31421U + 6927U;
+  }
+}
+
+static void test_queue_single(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, &n);
+  }
+  for(int i = 0; i < conso_count; i++) {
+    m_thread_create (idx_c[i], conso_spsc, &n);
+  }
+  size_t n2 = conso_count;
+  m_thread_create(idx_final, final_spsc, &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);
+}
+
+/********************************************************************************************/
+
+#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);
+}
+
+/********************************************************************************************/
+
+DEQUE_DEF(deque_uint, unsigned int)
+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)
+CONCURRENT_DEF(cdeque_ull, deque_ull_t, M_OPEXTEND(DEQUE_OPLIST(deque_ull, M_DEFAULT_OPLIST), PUSH(deque_ull_push_front)))
+
+cdeque_uint_t g_buff_conc;
+cdeque_ull_t g_final_conc;
+
+static void final_conc(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++) {
+    cdeque_ull_pop_blocking(&j, g_final_conc, true);
+    s += j;
+  }
+  g_result = s;
+}
+
+static void conso_conc(void *arg)
+{
+  unsigned int j;
+  size_t *p_n = arg;
+  size_t n = *p_n;
+  unsigned long long s = 0;
+  for(int i = 0; i < n;i++) {
+    cdeque_uint_pop_blocking(&j, g_buff_conc, true);
+    s += j;
+  }
+  cdeque_ull_push(g_final_conc, s);
+}
+
+static void prod_conc(void *arg)
+{
+  size_t *p_n = arg;
+  size_t n = *p_n;
+  size_t r = n;
+  for(unsigned int i = 0; i < n;i++) {
+    cdeque_uint_push(g_buff_conc, r );
+    r = r * 31421U + 6927U;
+  }
+}
+
+static void test_queue_concurrent(size_t n)
+{
+  const int cpu_count   = n > SIZE_LIMIT ? 2 : 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 CONCURRENT performance.\n");
+    return;
+  }
+  n = n > SIZE_LIMIT ? n - SIZE_LIMIT : n;
+  // Init
+  cdeque_uint_init(g_buff_conc);
+  cdeque_ull_init (g_final_conc);
+
+  // 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_conc, &n);
+  }
+  for(int i = 0; i < conso_count; i++) {
+    m_thread_create (idx_c[i], conso_conc, &n);
+  }
+  size_t n2 = conso_count;
+  m_thread_create(idx_final, final_conc, &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
+  cdeque_ull_clear(g_final_conc);
+  cdeque_uint_clear(g_buff_conc);
 }
 
 /********************************************************************************************/
@@ -476,45 +839,33 @@ static void test_core_hash(size_t n)
 
 /********************************************************************************************/
 
+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},
+  { 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}
+};
 
 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 == 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 == 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);
 }
-

bench/bench-nedtries.c

@@ -26,7 +26,7 @@ static inline size_t fookeyfunct(const foo_t *r)
 NEDTRIE_GENERATE(static, foo_tree_s, foo_s, link, fookeyfunct, NEDTRIE_NOBBLEZEROS(foo_tree_s))
 
 static void
-test_dict(unsigned long  n)
+test_dict(size_t  n)
 {
   foo_tree_t footree;
   NEDTRIE_INIT(&footree);
@@ -58,7 +58,7 @@ test_dict(unsigned long  n)
 }
 
 static void
-test_dict_noalloc(unsigned long  n)
+test_dict_noalloc(size_t  n)
 {
   foo_tree_t footree;
   NEDTRIE_INIT(&footree);
@@ -87,15 +87,13 @@ test_dict_noalloc(unsigned long  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);
 }
-

bench/bench-qlibc.c

@@ -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);
 }

bench/bench-qt.cpp

@@ -72,7 +72,7 @@ static void test_rbtree(size_t n)
 /********************************************************************************************/
 
 static void
-test_dict1(unsigned long  n)
+test_dict1(size_t  n)
 {
   QMap<unsigned long, unsigned long> dict;
 
@@ -92,7 +92,7 @@ test_dict1(unsigned long  n)
 /********************************************************************************************/
 
 static void
-test_dict2(unsigned long  n)
+test_dict2(size_t  n)
 {
   QHash<unsigned long, unsigned long> dict;
 
@@ -126,7 +126,7 @@ uint qHash(const char_array_s &k)
 };
 
 static void
-test_dict_big(unsigned long  n)
+test_dict_big(size_t  n)
 {
   QHash<char_array_s, char_array_s> dict;
 
@@ -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);
 }

bench/bench-rigtorp-hashmap.cpp

@@ -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);
+}

bench/bench-sparsepp.cpp

@@ -25,7 +25,7 @@ using namespace std;
 /********************************************************************************************/
 
 static void
-test_dict2(unsigned long  n)
+test_dict2(size_t  n)
 {
   sparse_hash_map<unsigned long, unsigned long> dict;
 
@@ -63,7 +63,7 @@ namespace std {
 }
 
 static void
-test_dict_big(unsigned long  n)
+test_dict_big(size_t  n)
 {
   sparse_hash_map<char_array_s, char_array_s> dict;
 
@@ -87,7 +87,7 @@ test_dict_big(unsigned long  n)
 
 /********************************************************************************************/
 static void
-test_dict_str(unsigned long  n)
+test_dict_str(size_t  n)
 {
   sparse_hash_map<string, string> dict;
 
@@ -109,14 +109,14 @@ test_dict_str(unsigned long  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);
 }

bench/bench-stl.cpp

@@ -73,7 +73,7 @@ static void test_rbtree(size_t n)
 /********************************************************************************************/
 
 static void
-test_dict1(unsigned long  n)
+test_dict1(size_t  n)
 {
   map<unsigned long, unsigned long> dict;
 
@@ -93,7 +93,7 @@ test_dict1(unsigned long  n)
 /********************************************************************************************/
 
 static void
-test_dict2(unsigned long  n)
+test_dict2(size_t  n)
 {
   unordered_map<unsigned long, unsigned long> dict;
 
@@ -110,6 +110,24 @@ test_dict2(unsigned long  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 {
@@ -131,7 +149,7 @@ namespace std {
 }
 
 static void
-test_dict_big(unsigned long  n)
+test_dict_big(size_t  n)
 {
   unordered_map<char_array_s, char_array_s> dict;
 
@@ -155,19 +173,19 @@ test_dict_big(unsigned long  n)
 
 /********************************************************************************************/
 static void
-test_dict_str(unsigned long  n)
+test_dict_str(size_t  n)
 {
   unordered_map<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();
+    string s1 = to_string(rand_get());
+    string s2 = to_string(rand_get());
     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();
+    string s1 = to_string (rand_get());
     unordered_map<string, string>::iterator it = dict.find(s1);
     if (it != dict.end())
       s ++;
@@ -176,19 +194,19 @@ test_dict_str(unsigned long  n)
 }
 
 static void
-test_dict_str2(unsigned long  n)
+test_dict_str2(size_t  n)
 {
   map<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();
+    string s1 = to_string(rand_get());
+    string s2 = to_string(rand_get());
     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();
+    string s1 = to_string(rand_get());
     map<string, string>::iterator it = dict.find(s1);
     if (it != dict.end())
       s ++;
@@ -220,28 +238,22 @@ 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},
+  { 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);
 }

bench/bench-string-2.cpp

@@ -0,0 +1,338 @@
+/*
+ * M*LIB - String Bench
+ *
+ * Copyright (c) 2017-2020, 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>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "common.h"
+
+#include "m-string.h"
+
+#ifdef BENCH_CAN_USE_SDS
+extern "C" {
+#include "sds.h"
+};
+#endif
+
+#ifdef BENCH_CAN_USE_RAPIDSTRING
+#include "rapidstring.h"
+#endif
+
+#ifdef BENCH_CAN_USE_BSTRLIB
+#include "bstrlib.h"
+#include "bstrwrap.h"
+#include "bstraux.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;
+
+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]];
+  }
+
+  size_t pos = 0;
+  do {
+    pos = str.find("1234", pos);
+    if (pos != string::npos) {
+      str.replace (pos, 4, "WELL");
+    }
+  } while (pos != string::npos);
+
+  pos = 0;
+  do {
+    pos = str.find("56789", pos);
+    if (pos != string::npos) {
+      str.replace (pos, 5, "DONE");
+    }
+  } while (pos != string::npos);
+
+  return str.length();
+}
+
+size_t bench_mlib(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_printf(tab[i], "%u", rand_get());
+  }
+  // P2
+  string_t str;
+  string_init(str);
+  for(unsigned i = 0; i < n; i++) {
+    string_cat(str, tab[permutation_tab[i]]);
+  }
+  // P3
+  size_t i = 0;
+  do {
+    i = string_replace_str(str, "1234", "WELL", i);
+  } while (i != STRING_FAILURE);
+  // P4
+  i = 0;
+  do {
+    i = string_replace_str(str, "56789", "DONE", i);
+  } while (i != STRING_FAILURE);
+  size_t length = string_size(str);
+  // Clean
+  string_clear(str);
+  for(unsigned i = 0; i < n; i++) {
+    string_clear(tab[i]);
+  }
+  free(tab);
+  return length;
+}
+
+
+#ifdef BENCH_CAN_USE_BSTRLIB
+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]];
+  }
+
+  size_t pos = 0;
+  do {
+    pos = str.find("1234", pos);
+    if (pos != string::npos) {
+      str.replace (pos, 4, "WELL");
+    }
+  } while (pos != string::npos);
+
+  pos = 0;
+  do {
+    pos = str.find("56789", pos);
+    if (pos != string::npos) {
+      str.replace (pos, 5, "DONE");
+    }
+  } while (pos != string::npos);
+
+  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;
+}
+
+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
+  size_t pos = 0;
+  do {
+    char *p = strstr(&str[pos], "1234");
+    pos = p == NULL ? -1U : (p - str);
+    if (pos != -1U) {
+      str = SDS_replace_at(str, pos, 4, "WELL");
+    }
+  } while (pos != -1U);
+  // P4
+  pos = 0;
+  do {
+    char *p = strstr(&str[pos], "56789");
+    pos = p == NULL ? -1U : (p - str);
+    if (pos != -1U) {
+      str = SDS_replace_at(str, pos, 5, "DONE");
+    }
+  } while (pos != -1U);
+  size_t length = sdslen(str);
+  // Clean
+  sdsfree(str);
+  for(unsigned i = 0; i < n; i++) {
+    sdsfree(tab[i]);
+  }
+  free(tab);
+  return length;
+}
+#endif
+
+#ifdef BENCH_CAN_USE_RAPIDSTRING
+void RAPIDSTRING_replace_at(rapidstring *str, size_t pos, size_t len, const char str2[])
+{
+  // simple implementation as replace is not available
+  rapidstring a;
+  
+  rs_init_w_n(&a, rs_data(str), pos);
+  rs_cat(&a, str2);
+  rs_cat(&a, &rs_data(str)[pos+len] );
+  rs_free(str);
+  *str = a;
+}
+
+size_t bench_rapidstring(unsigned n)
+{
+  rapidstring *tab = (rapidstring*) malloc (n * sizeof (rapidstring));
+  assert (tab != 0);
+  // P1
+  for(unsigned i = 0; i < n; i++) {
+    char tmp[10];
+    sprintf(tmp, "%u", rand_get());
+    rs_init_w(&tab[i], tmp);
+  }
+  // P2
+  rapidstring str;
+  rs_init(&str);
+  for(unsigned i = 0; i < n; i++) {
+    rs_cat_rs(&str, &tab[permutation_tab[i]]);
+  }
+  // P3
+  size_t pos = 0;
+  do {
+    char *p = strstr(&rs_data(&str)[pos], "1234");
+    pos = p == NULL ? -1U : (p - rs_data(&str));
+    if (pos != -1U) {
+      RAPIDSTRING_replace_at(&str, pos, 4, "WELL");
+    }
+  } while (pos != -1U);
+  // P4
+  pos = 0;
+  do {
+    char *p = strstr(&rs_data(&str)[pos], "56789");
+    pos = p == NULL ? -1U : (p - rs_data(&str));
+    if (pos != -1U) {
+      RAPIDSTRING_replace_at(&str, pos, 5, "DONE");
+    }
+  } while (pos != -1U);
+  size_t length = rs_len(&str);
+  // Clean
+  rs_free(&str);
+  for(unsigned i = 0; i < n; i++) {
+    rs_free(&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_RAPIDSTRING
+  case 3:
+    length = bench_rapidstring(n);
+    name = "RAPID";
+    break;
+#endif
+#ifdef BENCH_CAN_USE_BSTRLIB
+  case 4:
+    length = bench_bstrlib(n);
+    name = "BSTRLIB";
+    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;
+}
+

bench/bench-tommyds.c

@@ -124,7 +124,7 @@ static int equal_func(const void* arg, const void *obj_p)
 }
 
 static void
-test_dict(unsigned long  n)
+test_dict(size_t  n)
 {
   tommy_hashlin dict;
   tommy_hashlin_init(&dict);
@@ -174,7 +174,7 @@ static size_t char_hash(const char *s)
 }
 
 static void
-test_dict_big(unsigned long  n)
+test_dict_big(size_t  n)
 {
   tommy_hashlin dict;
   tommy_hashlin_init(&dict);
@@ -206,18 +206,16 @@ test_dict_big(unsigned long  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);
 }

bench/bench-uthash.c

@@ -1,4 +1,5 @@
 #define NDEBUG
+#define  _GNU_SOURCE
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -85,7 +86,7 @@ struct hash_i_node_s {
 };
 
 static void
-test_dict(unsigned long  n)
+test_dict(size_t  n)
 {
   struct hash_i_node_s *dict = NULL;
   
@@ -131,7 +132,7 @@ struct hash_b_node_s {
 };
 
 static void
-test_dict_big(unsigned long  n)
+test_dict_big(size_t  n)
 {
   struct hash_b_node_s *dict = NULL;
 
@@ -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);
 }
-

bench/bench-xxhash.c

@@ -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);
 }
-

bench/common.c

@@ -0,0 +1,304 @@
+/*
+ * M*LIB - common functions for bench module
+ *
+ * Copyright (c) 2017-2020, 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)] [--grapĥ]\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 plot.dat\n");
+      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);
+      }
+      
+      // 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;
+}

bench/common.h

@@ -1,7 +1,7 @@
 /*
  * M*LIB - common functions for bench module
  *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2020, 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,35 +25,59 @@
 #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-mutex.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. */
 #if defined(_WIN32)
 /* WINDOWS variant */
-#include <windows.h>
-
-static unsigned long long
+static inline unsigned long long
 cputime (void)
 {
-	LARGE_INTEGER freq, val;
-	QueryPerformanceFrequency(&freq);
-	QueryPerformanceCounter(&val);
-	return (unsigned long long) (1000000. * (double) val.QuadPart / (double) freq.QuadPart);
+  LARGE_INTEGER freq, val;
+  QueryPerformanceFrequency(&freq);
+  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,41 +86,61 @@ cputime (void)
 
 #endif
 
-unsigned long g_result;
-unsigned int randValue = 0;
+// The result of the bench
+extern unsigned long g_result;
 
-static void rand_init(void)
+// The rand value
+extern
+#if defined(MULTI_THREAD_MEASURE)
+M_THREAD_ATTR
+#endif
+unsigned int randValue;
+
+// 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();
+  result = (double)(end-start) / 1000.0;
   end = (end - start) / 1000U;
-  printf ("%s %lu ms for n = %lu [r=%lu]\n", str, (unsigned long) end, (unsigned long) n, g_result);
+  if (str != NULL) {
+    printf ("%20.20s time %lu ms for n = %lu [r=%lu]\n", str, (unsigned long) end, (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)
@@ -120,4 +164,9 @@ static inline int get_cpu_count(void)
 #endif
 }
 
+#ifdef __cplusplus
+extern "C"
+#endif
+void compiler_barrier(void *p);
+
 #endif

bench/max-dict.c

@@ -1,7 +1,7 @@
 /*
  * MLIB - TEST module
  *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2020, 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);

bench/nucleotide/nucleotide.c

@@ -3,50 +3,51 @@
 //
 // Original version Contributed by Jeremy Zerfas
 // M*LIB port contributed by Patrick Pélissier
-// gcc -O2 -march=native nucleotide.c -I../.. -std=c11 -lpthread -DNDEBUG
-
 #define NDEBUG
-
 #include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
-#include <time.h>
-#include <sys/time.h>
 #include <assert.h>
 
 #include "m-worker.h"
 #include "m-dict.h"
+#include "m-bptree.h"
 
 // This controls the maximum length for each set of oligonucleotide frequencies
 // and each oligonucleotide count output by this program.
 #define MAXIMUM_OUTPUT_LENGTH 4096
 
-// Define Open Addressing dictionnary. Need to define how to handle out of bound data.
-static inline bool oor_equal_p(uint64_t k, unsigned char n)
+// Number of outputs to display
+#define MAXMUM_NUMBER_OUTPUT 7
+
+/* Define the needed containers */
+/* Define Open Addressing dictionary of uint64_t --> uint32_t. Need to define how to handle out of bound data. */
+static inline bool my_oor_equal_p(uint64_t k, unsigned char n)
 {
   return k == ~(uint64_t) n;
 }
-static inline void oor_set(uint64_t *k, unsigned char n)
+static inline void my_oor_set(uint64_t *k, unsigned char n)
 {
   *k = ~(uint64_t)n;
 }
-// Custom hash function.
 static inline size_t my_hash(uint64_t key)
 {
   return ((key) ^ (key)>>7);
 }
-// Define a dictionnary of uint64_t --> uint32_t
+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(oor_equal_p), OOR_SET(oor_set M_IPTR)),
-             uint32_t, M_DEFAULT_OPLIST)
-// Define oplist of dictionary
-#define OLIGONUCLEOTIDE_OPLIST DICT_OPLIST(dict_oligonucleotide, M_OPEXTEND(M_DEFAULT_OPLIST, HASH(oor_hash), OOR_EQUAL(oor_equal_p), OOR_SET(oor_set M_IPTR)), M_DEFAULT_OPLIST)
+             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)))
+#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)
 
-typedef struct {
-  uint64_t	key;
-  uint32_t	value;
-} element;
+// Define a B*TREE-21 of uint32_t --> uint64_t and register its oplist
+#define TREE_CMP(a,b)      ((a) > (b) ? -1 : (a) < (b)) /* reverse natural order */
+BPTREE_DEF2(tree_dict_oligonucleotide, 21, uint32_t, M_OPEXTEND(M_DEFAULT_OPLIST, CMP(TREE_CMP)), uint64_t, M_DEFAULT_OPLIST)
+#define M_OPL_tree_dict_oligonucleotide_t() BPTREE_OPLIST2(tree_dict_oligonucleotide, M_DEFAULT_OPLIST, M_DEFAULT_OPLIST)
+
+/* Define the data to analyse (a plain array) */
+ARRAY_DEF(polynucleotide, unsigned char)
 
 // Macro to convert a nucleotide character to a code. Note that upper and lower
 // case ASCII letters only differ in the fifth bit from the right and we only
@@ -55,143 +56,167 @@ typedef struct {
 // characters other than 'A', 'C', 'G', and 'T' aren't used.
 #define CODE_FOR_NUCLEOTIDE(nucleotide) (" \0 \1\3  \2"[nucleotide & 0x7])
 
-
 // And one more macro to convert the codes back to nucleotide characters.
 #define NUCLEOTIDE_FOR_CODE(code) ("ACGT"[code & 0x3])
 
+static worker_t worker;
 
-// Function to use when sorting elements with qsort() later. Elements with
-// larger values will come first and in cases of identical values then elements
-// with smaller keys will come first.
-static int element_Compare(const void *a, const void *b)
+// Read from the given stream the data and fill in the array with the converted one.
+static void polynucleotide_init_stream(polynucleotide_t p, FILE *stream)
 {
-  const element * const left_Element = a;
-  const element * const right_Element = b;
-  // Sort based on element values.
-  if(left_Element->value < right_Element->value) return 1;
-  if(left_Element->value > right_Element->value) return -1;
-  
-  // If we got here then both items have the same value so then sort based on
-  // key.
-  return left_Element->key > right_Element->key ? 1 : -1;
+  char buffer[MAXIMUM_OUTPUT_LENGTH], c;
+
+  polynucleotide_init(p);
+  polynucleotide_reserve(p, MAXIMUM_OUTPUT_LENGTH);
+  // Find the start of the third polynucleotide.
+  while(fgets(buffer, sizeof(buffer), stream) && memcmp(">THREE", buffer, 6));
+  // Start reading and encoding the third polynucleotide.
+  while(fgets(buffer, sizeof(buffer), stream) && buffer[0]!='>'){
+    for(size_t i = 0; (c = buffer[i]) !='\0'; i++) {
+      if (c != '\n') {
+          polynucleotide_push_back(p, CODE_FOR_NUCLEOTIDE(c));
+      }
+    }
+  }
 }
 
-
-// Generate frequencies for all oligonucleotides in polynucleotide that are of
-// desired_Length_For_Oligonucleotides and then save it to output.
-static void
-generate_Frequencies_For_Desired_Length_Oligonucleotides(const char polynucleotide[],
-                                                         const int polynucleotide_Length,
-                                                         const int desired_Length_For_Oligonucleotides,
-                                                         char * const output)
-{  
-  assert (2*desired_Length_For_Oligonucleotides <= 64);
-
-  dict_oligonucleotide_t hash_Table;
-  dict_oligonucleotide_init(hash_Table);
-  
-  uint64_t key=0;
-  const uint64_t mask=(1ULL<<(2*desired_Length_For_Oligonucleotides))-1;
+// This is the function which does 95% of the work.
+/* NOTE: paralelisation is not done by cutting the input set in two.
+   This is not efficient as the size of the output table will be the same
+   as for the whole table. */
+static void init_hash(dict_oligonucleotide_t hash_Table, const size_t size, const unsigned char tab[size], const size_t desiredLength, const size_t offset, const size_t skip)
+{
+  uint64_t key = 0;
+  const uint64_t mask = (1ULL<<(2*desiredLength))-1;
+  assert (2*desiredLength < 64 && desiredLength < size);
+  assert ((1 == skip || 4 == skip) && offset < size);
   
   // For the first several nucleotides we only need to append them to key in
-  // preparation for the insertion of complete oligonucleotides to hash_Table.
-  for(int i=0; i<desired_Length_For_Oligonucleotides-1; i++)
-    key=(key<<2 & mask) | polynucleotide[i];
+  // preparation for the insertion of complete oligonucleotides to hash.
+  for(size_t i = 0; i < desiredLength - 1 + offset; i++)
+    key = (key<<2) | tab[i];
+  key &= mask;
+  
+  dict_oligonucleotide_t hash;
+  dict_oligonucleotide_init(hash);
 
   // Add all the complete oligonucleotides of
-  // desired_Length_For_Oligonucleotides to hash_Table and update the count
-  // for each oligonucleotide.
-  for(int i=desired_Length_For_Oligonucleotides-1
-        ; i<polynucleotide_Length; i++){
-    
-    key=(key<<2 & mask) | polynucleotide[i];
-    
-    uint32_t *p = dict_oligonucleotide_get(hash_Table, key);
-    if (p != NULL)
-      (*p) ++;
-    else {
-      dict_oligonucleotide_set_at(hash_Table, key, 1);
+  // desiredLength to hash, updating their count
+  if (skip == 1) {
+    for(size_t i = desiredLength-1+offset ; i < size; i++) {
+      key = (key<<2) | tab[i+0];
+      key &= mask;
+      uint32_t *p = dict_oligonucleotide_get(hash, key);
+      if (p != NULL) {
+	(*p) ++;
+      } else {
+	dict_oligonucleotide_set_at(hash, key, 1);
+      }
+    }
+  } else { // skip = 4
+    for(size_t i = desiredLength-1+offset ; i < size; i+=4) {
+      for (size_t j = 0; j < 4; j++)
+	key = (key<<2) | tab[i+j];
+      key &= mask;
+      uint32_t *p = dict_oligonucleotide_get(hash, key);
+      if (p != NULL) {
+	(*p) ++;
+      } else {
+	dict_oligonucleotide_set_at(hash, key, 1);
+      }
     }
   }
-  
-  // Create an array of elements from hash_Table.
-  int elements_Array_Size=dict_oligonucleotide_size(hash_Table), i=0;
-  element * elements_Array=malloc(elements_Array_Size*sizeof(element));
-  if (!elements_Array) abort();
-  for M_EACH(item, hash_Table, OLIGONUCLEOTIDE_OPLIST) {
-      elements_Array[i++]=((element){item->key, item->value});
-    }
-  // Clear the hash table
-  dict_oligonucleotide_clear(hash_Table);
-  
-  // Sort elements_Array.
-  qsort(elements_Array, elements_Array_Size, sizeof(element), element_Compare);
-  
-  // Print the frequencies for each oligonucleotide.
-  for(int output_Position=0, i=0; i<elements_Array_Size; i++) {
-    
-    // Convert the key for the oligonucleotide to a string.
-    char oligonucleotide[desired_Length_For_Oligonucleotides+1];
-    for(int j=desired_Length_For_Oligonucleotides-1; j>-1; j--){
-      oligonucleotide[j]=NUCLEOTIDE_FOR_CODE(elements_Array[i].key);
-      elements_Array[i].key>>=2;
-    }
-    oligonucleotide[desired_Length_For_Oligonucleotides]='\0';
-    
-    // Output the frequency for oligonucleotide to output.
-    output_Position+=snprintf(output+output_Position
-                              , MAXIMUM_OUTPUT_LENGTH-output_Position, "%s %.3f\n", oligonucleotide
-                              , 100.0f*elements_Array[i].value
-                              /(polynucleotide_Length-desired_Length_For_Oligonucleotides+1));
-  }
-  
-  free(elements_Array);
+  dict_oligonucleotide_init_move(hash_Table, hash);
 }
 
+static void compute_hash(dict_oligonucleotide_t hash_Table, const polynucleotide_t p, const size_t desiredLength)
+{
+  size_t size = polynucleotide_size(p);
+  unsigned char *tab = polynucleotide_get(p, 0);
+  if (desiredLength < 8) {
+    init_hash(hash_Table, size, tab, desiredLength, 0, 1);
+    return;
+  }
+
+  worker_sync_t block;   // Define a synchronization block
+  worker_start(block, worker);
+  dict_oligonucleotide_t hash_Table3, *p_hash_Table3 = &hash_Table3;  
+  dict_oligonucleotide_t hash_Table2, *p_hash_Table2 = &hash_Table2;
+  dict_oligonucleotide_t hash_Table1, *p_hash_Table1 = &hash_Table1;
+  WORKER_SPAWN(block, (p_hash_Table1, size, tab, desiredLength), {
+      init_hash(*p_hash_Table1, size, tab, desiredLength, 3, 4);
+    }, (/*no output*/));
+  WORKER_SPAWN(block, (p_hash_Table2, size, tab, desiredLength), {
+      init_hash(*p_hash_Table2, size, tab, desiredLength, 2, 4);
+    }, (/*no output*/));
+  WORKER_SPAWN(block, (p_hash_Table3, size, tab, desiredLength), {
+      init_hash(*p_hash_Table3, size, tab, desiredLength, 1, 4);
+    }, (/*no output*/));
+  init_hash(hash_Table, size, tab, desiredLength, 0, 4);
+  worker_sync(block);
+  
+  // Merge all hashtables
+  dict_oligonucleotide_splice(hash_Table, hash_Table1);
+  dict_oligonucleotide_splice(hash_Table, hash_Table2);
+  dict_oligonucleotide_splice(hash_Table, hash_Table3);
+  // Clear extra hashtables
+  dict_oligonucleotide_clear(hash_Table3);
+  dict_oligonucleotide_clear(hash_Table2);
+  dict_oligonucleotide_clear(hash_Table1);
+}
+
+// Generate frequencies for all oligonucleotides in polynucleotide that are of
+// desiredLength and then save it to output.
+static void compute_freq(const polynucleotide_t p, const size_t desiredLength, char output[])
+{  
+  dict_oligonucleotide_t hash_Table;
+  compute_hash(hash_Table, p, desiredLength);
+
+  // Order key is the count frequency (inverse value & key)
+  tree_dict_oligonucleotide_t tree;
+  tree_dict_oligonucleotide_init(tree);
+  for M_EACH(item, hash_Table, dict_oligonucleotide_t) {
+    tree_dict_oligonucleotide_set_at (tree, item->value, item->key);
+  }
+
+  // Create Output
+  char oligonucleotide[64];
+  const double invSum = 100.0 / (double) (polynucleotide_size(p) - desiredLength + 1);
+  int output_Position = 0;
+  for M_EACH(item, tree, tree_dict_oligonucleotide_t) {
+    // Convert the key for the oligonucleotide to a string.
+    uint64_t freq  = *item->value_ptr;
+    uint32_t count = *item->key_ptr;
+    for(size_t j = desiredLength-1; j < desiredLength; j--){
+      oligonucleotide[j]=NUCLEOTIDE_FOR_CODE(freq);
+      freq>>=2;
+    }
+    oligonucleotide[desiredLength]='\0';
+    // Output the frequency for oligonucleotide to output.
+    output_Position+=snprintf(output+output_Position, MAXIMUM_OUTPUT_LENGTH-output_Position,
+                              "%s %.3f\n", oligonucleotide, invSum * count);
+  }
+  
+  dict_oligonucleotide_clear(hash_Table);
+  tree_dict_oligonucleotide_clear(tree);
+}
 
 // Generate a count for the number of times oligonucleotide appears in
 // polynucleotide and then save it to output.
-static void
-generate_Count_For_Oligonucleotide(const char * const polynucleotide,
-                                   const int polynucleotide_Length,
-                                   const char * const oligonucleotide,
-                                   char * const output)
+static void compute_count(polynucleotide_t p, const char oligonucleotide[], char output[])
 {
-  const int oligonucleotide_Length=strlen(oligonucleotide);
-  assert (2*oligonucleotide_Length <= 64);
-  
+  const size_t oligonucleotide_Length = strlen(oligonucleotide);
   dict_oligonucleotide_t hash_Table;
-  dict_oligonucleotide_init(hash_Table);
-  
-  uint64_t key = 0;
-  const uint64_t mask=(1ULL<<(2*oligonucleotide_Length))-1;
-  
-  // For the first several nucleotides we only need to append them to key in
-  // preparation for the insertion of complete oligonucleotides to hash_Table.
-  for(int i=0; i<oligonucleotide_Length-1; i++)
-    key=(key<<2 & mask) | polynucleotide[i];
-
-  // Add all the complete oligonucleotides of oligonucleotide_Length to
-  // hash_Table and update the count for each oligonucleotide.
-  for(int i=oligonucleotide_Length-1; i<polynucleotide_Length; i++){
-    key=(key<<2 & mask) | polynucleotide[i];
-    
-    uint32_t *p = dict_oligonucleotide_get(hash_Table, key);
-    if (p != NULL)
-      (*p) ++;
-    else {
-      dict_oligonucleotide_set_at(hash_Table, key, 1);
-    }
-  }
+  compute_hash(hash_Table, p, oligonucleotide_Length);
   
   // Generate the key for oligonucleotide.
-  key=0;
-  for(int i=0; i<oligonucleotide_Length; i++)
-    key=(key<<2) | CODE_FOR_NUCLEOTIDE(oligonucleotide[i]);
+  uint64_t key=0;
+  for(size_t i=0; i<oligonucleotide_Length; i++)
+    key = (key<<2) | CODE_FOR_NUCLEOTIDE(oligonucleotide[i]);
   
   // Output the count for oligonucleotide to output.
-  uint32_t *p = dict_oligonucleotide_get(hash_Table, key);
-  uintmax_t count= p== NULL ? 0 : *p;
+  uint32_t *val = dict_oligonucleotide_get(hash_Table, key);
+  uintmax_t count= val== NULL ? 0 : *val;
   snprintf(output, MAXIMUM_OUTPUT_LENGTH, "%ju\t%s", count, oligonucleotide);
   
   dict_oligonucleotide_clear(hash_Table);
@@ -199,94 +224,43 @@ generate_Count_For_Oligonucleotide(const char * const polynucleotide,
 
 int main()
 {
-  char buffer[MAXIMUM_OUTPUT_LENGTH];
-  worker_t worker;
-
   // Initialize the different worker threads by auto-detecting the number of cores of the system
-  worker_init(worker, 0, 1, NULL);
+  worker_init(worker, -1, 0, NULL);
+
+  // Read the input
+  polynucleotide_t p, *ptr = &p;
+  polynucleotide_init_stream(p, stdin);
   
-  // Find the start of the third polynucleotide.
-  while(fgets(buffer, sizeof(buffer), stdin) && memcmp(">THREE", buffer
-                                                       , sizeof(">THREE")-1));
-  
-  // Start with 1 MB of storage for reading in the polynucleotide and grow
-  // geometrically.
-  int polynucleotide_Capacity=1048576;
-  int polynucleotide_Length=0;
-  char * polynucleotide=malloc(polynucleotide_Capacity);
-  if (!polynucleotide) abort();
-  
-  // Start reading and encoding the third polynucleotide.
-  while(fgets(buffer, sizeof(buffer), stdin) && buffer[0]!='>'){
-    for(int i=0; buffer[i]!='\0'; i++)
-      if(buffer[i]!='\n')
-        polynucleotide[polynucleotide_Length++]
-          =CODE_FOR_NUCLEOTIDE(buffer[i]);
-    
-    // Make sure we still have enough memory allocated for any potential
-    // nucleotides in the next line.
-    if(polynucleotide_Capacity-polynucleotide_Length<sizeof(buffer)) {
-      polynucleotide=realloc(polynucleotide, polynucleotide_Capacity*=2);
-      if (!polynucleotide) abort();
-    }
-  }
-  
-  char output_Buffer[7][MAXIMUM_OUTPUT_LENGTH];
-  char (*output)[MAXIMUM_OUTPUT_LENGTH] = output_Buffer;
+  // Prepare outputs
+  char outputBuffer[MAXMUM_NUMBER_OUTPUT][MAXIMUM_OUTPUT_LENGTH];
+  char (*output)[MAXIMUM_OUTPUT_LENGTH] = outputBuffer;
   
   // Do the following functions in parallel.
-  // Define a synchronization block
-  worker_sync_t block;
-  worker_start(block);
+  worker_sync_t block;   // Define a synchronization block
+  worker_start(block, worker);
   
-  WORKER_SPAWN(worker, block, (polynucleotide, polynucleotide_Length, output), {
-      generate_Count_For_Oligonucleotide(polynucleotide,
-                                         polynucleotide_Length,
-                                         "GGTATTTTAATTTATAGT", output[6]);
+  WORKER_SPAWN(block, (ptr, output), {
+      compute_count(*ptr, "GGTATTTTAATTTATAGT", output[6]);
     }, (/*no output*/));
-
-  WORKER_SPAWN(worker, block, (polynucleotide, polynucleotide_Length, output), {
-      generate_Count_For_Oligonucleotide(polynucleotide,
-                                         polynucleotide_Length,
-                                         "GGTATTTTAATT", output[5]);
+  WORKER_SPAWN(block, (ptr, output), {
+      compute_count(*ptr, "GGTATTTTAATT", output[5]);
     }, (/*no output*/));
-  
-  WORKER_SPAWN(worker, block, (polynucleotide, polynucleotide_Length, output), {
-      generate_Count_For_Oligonucleotide(polynucleotide,
-                                         polynucleotide_Length,
-                                         "GGTATT", output[4]);
+  WORKER_SPAWN(block, (ptr, output), {
+      compute_count(*ptr, "GGTATT", output[4]);
     }, (/*no output*/));
-  
-  WORKER_SPAWN(worker, block, (polynucleotide, polynucleotide_Length, output), {
-      generate_Count_For_Oligonucleotide(polynucleotide,
-                                         polynucleotide_Length,
-                                         "GGTA", output[3]);
+  WORKER_SPAWN(block, (ptr, output), {
+      compute_count(*ptr, "GGTA", output[3]);
     }, (/*no output*/));
-  
-  WORKER_SPAWN(worker, block, (polynucleotide, polynucleotide_Length, output), {
-      generate_Count_For_Oligonucleotide(polynucleotide,
-                                         polynucleotide_Length,
-                                         "GGT", output[2]);  
-    }, (/*no output*/));
-
-  WORKER_SPAWN(worker, block, (polynucleotide, polynucleotide_Length, output), {
-      generate_Frequencies_For_Desired_Length_Oligonucleotides(polynucleotide,
-                                                               polynucleotide_Length,
-                                                               2,
-                                                               output[1]);
-    }, (/*no output*/));
-
-  generate_Frequencies_For_Desired_Length_Oligonucleotides(polynucleotide,
-                                                           polynucleotide_Length,
-                                                           1,
-                                                           output[0]);
+  compute_count(*ptr, "GGT", output[2]);  
+  compute_freq(*ptr, 2, output[1]);
+  compute_freq(p, 1, output[0]);
   worker_sync(block);
   
   // Output the results to stdout.
-  for(int i=0; i<7; i++)
-    printf("%s\n", output_Buffer[i]);
+  for(int i=0; i<MAXMUM_NUMBER_OUTPUT; i++)
+    printf("%s\n", outputBuffer[i]);
   
-  free(polynucleotide);
+  polynucleotide_clear(p);
   worker_clear(worker);
   
   return 0;

bench/udb/Makefile

@@ -0,0 +1,53 @@
+CC=		gcc
+CXX=		g++
+CFLAGS=		-g -Wall -O2 -fomit-frame-pointer -march=native -lm -include stddef.h
+CXXFLAGS=	$(CFLAGS)
+LDFLAGS=	
+OBJS=		
+LIBS=		-lm
+
+all: run
+
+benchmarks:
+	git clone https://github.com/attractivechaos/benchmarks.git
+
+build: benchmarks
+	mkdir -p benchmarks/udb/mlib
+	cp test-mlib.c benchmarks/udb/mlib/test.c
+	cp Makefile-mlib benchmarks/udb/mlib/Makefile
+	mkdir -p benchmarks/udb/mlib-oa
+	cp test-mlib-oa.c benchmarks/udb/mlib-oa/test.c
+	cp Makefile-mlib benchmarks/udb/mlib-oa/Makefile
+	touch build
+
+all-recur: build
+	cd benchmarks/udb;					\
+	wdir=`pwd`; 						\
+	list_c=`find . -name 'test.c'`;				\
+	list_cc=`find . -name 'test.cc'`;			\
+	for t in $$list_c $$list_cc ; do 			\
+		subdir=`dirname $$t`;				\
+		cd $$subdir; 					\
+		$(MAKE) CC="$(CC)" CXX="$(CXX)" DFLAGS="$(DFLAGS)" CFLAGS="$(CFLAGS)" CXXFLAGS="$(CXXFLAGS)" || exit 1; 		\
+		cd $$wdir; 					\
+	done;
+
+run: all-recur
+	@cd benchmarks/udb;					\
+	echo ; echo "LIBRARY | INT TIME | STR TIME"	;	\
+	for i in `find . -name 'test'` ; do			\
+	    printf "%s|" `dirname $$i|sed -e 's+./++g'`;	\
+	    $$i -is | awk '					\
+		/\[int data\] # element/ {  nbInt= $$5 }	\
+		/\[int data\] CPU time/  {timeInt= $$5 }	\
+		/\[str data\] # element/ {  nbStr= $$5 }	\
+		/\[str data\] CPU time/  {timeStr= $$5 }	\
+		END { 						\
+		if (nbInt != 624444) timeInt="BRK" ; 		\
+		if (nbStr != 624444) timeStr="BRK" ;		\
+		print timeInt,"|" ,timeStr			\
+		}' ;						\
+	done
+
+clean:
+	rm -rf benchmarks build

bench/udb/Makefile-mlib

@@ -0,0 +1,22 @@
+CC=		gcc
+CFLAGS=		-g -Wall -O2 -march=native
+OBJS=		../benchmark/benchmark.o ../runit/runlib.o test.o
+DFLAGS=
+INCLUDES=	-I../benchmark -I../runit -I../../../../..
+LIBS=		
+
+.SUFFIXES:.c .o
+
+.c.o:
+		$(CC) -std=gnu11 -DNDEBUG -c $(INCLUDES) $(CFLAGS) $(DFLAGS) $< -o $@
+
+all:test
+
+test:$(OBJS)
+		$(CC) $(CFLAGS) -o $@ $(OBJS) $(LIBS)
+
+cleanlocal:
+		rm -f *.o a.out *~ test
+
+clean:cleanlocal
+

bench/udb/test-mlib-oa.c

@@ -0,0 +1,73 @@
+#include <string.h>
+
+#include "benchmark.h"
+#include "m-dict.h"
+#include "m-mempool.h"
+
+static inline bool oor_equal_p(int k, unsigned char n)
+{
+  return k == (int)-n - 1;
+}
+
+static inline void oor_set(int *k, unsigned char n)
+{
+  *k = (int)-n - 1;
+}
+
+DICT_OA_DEF2(dict_int,
+             int, M_OPEXTEND(M_DEFAULT_OPLIST, OOR_EQUAL(oor_equal_p), OOR_SET(oor_set M_IPTR)),
+             int, M_DEFAULT_OPLIST)
+
+static const char *const oor[2] = { "EMPTY", "DELETED" };
+
+static inline bool str_oor_equal_p(const char *k, unsigned char n)
+{
+return k == oor[n];
+}
+
+static inline void str_oor_set(const char * *k, unsigned char n)
+{
+*k = oor[n];
+}
+
+DICT_OA_DEF2(dict_str, const char *,
+          M_OPEXTEND (M_CSTR_OPLIST, OOR_EQUAL(str_oor_equal_p), OOR_SET(str_oor_set M_IPTR)),
+          int, M_DEFAULT_OPLIST)
+
+
+int test_int(int N, const unsigned *data)
+{
+  int ret;
+  M_LET(h, DICT_OPLIST(dict_int)) {
+    for (int i = 0; i < N; ++i) {
+      if (dict_int_get (h, data[i]) == NULL) {
+        dict_int_set_at (h, data[i], i);
+      } else {
+        dict_int_erase(h, data[i]);
+      }
+    }
+    ret = (int)dict_int_size(h);
+  }
+  return ret;
+}
+
+int test_str(int N, char * const *data)
+{
+  int ret;
+  M_LET(h, DICT_OPLIST(dict_str)) {
+    for (int i = 0; i < N; ++i) {
+      if (dict_str_get (h, data[i]) == NULL) {
+        dict_str_set_at (h, data[i], i);
+      } else {
+        dict_str_erase(h, data[i]);
+      }
+    }
+    ret = (int)dict_str_size(h);
+  }
+  return ret;
+}
+
+int main(int argc, char *argv[])
+{
+  return udb_benchmark(argc, argv, test_int, test_str);
+}

bench/udb/test-mlib.c

@@ -0,0 +1,53 @@
+#include <string.h>
+
+#include "benchmark.h"
+#include "m-dict.h"
+#include "m-mempool.h"
+
+DICT_STOREHASH_DEF2(dict_int,
+          int, M_OPEXTEND(M_DEFAULT_OPLIST, MEMPOOL(mpool_int), MEMPOOL_LINKAGE(static)),
+          int, M_DEFAULT_OPLIST)
+DICT_STOREHASH_DEF2(dict_str,
+          const char *, M_OPEXTEND (M_CSTR_OPLIST, MEMPOOL(mpool_str), MEMPOOL_LINKAGE(static)),
+          int, M_DEFAULT_OPLIST)
+
+int test_int(int N, const unsigned *data)
+{
+  int ret;
+  dict_int_list_pair_mempool_init(mpool_int);
+  M_LET(h, DICT_OPLIST(dict_int)) {
+    for (int i = 0; i < N; ++i) {
+      if (dict_int_get (h, data[i]) == NULL) {
+        dict_int_set_at (h, data[i], i);
+      } else {
+        dict_int_erase(h, data[i]);
+      }
+    }
+    ret = (int)dict_int_size(h);
+  }
+  dict_int_list_pair_mempool_clear(mpool_int);  
+  return ret;
+}
+
+int test_str(int N, char * const *data)
+{
+  int ret;
+  dict_str_list_pair_mempool_init(mpool_str);
+  M_LET(h, DICT_OPLIST(dict_str)) {
+    for (int i = 0; i < N; ++i) {
+      if (dict_str_get (h, data[i]) == NULL) {
+        dict_str_set_at (h, data[i], i);
+      } else {
+        dict_str_erase(h, data[i]);
+      }
+    }
+    ret = (int)dict_str_size(h);
+  }
+  dict_str_list_pair_mempool_clear(mpool_str);
+  return ret;
+}
+
+int main(int argc, char *argv[])
+{
+  return udb_benchmark(argc, argv, test_int, test_str);
+}

bench/udb2/Makefile

@@ -0,0 +1,33 @@
+CC=		gcc
+CXX=		g++
+CFLAGS=		-g -Wall -O2 -fomit-frame-pointer -march=native -lm -include stddef.h
+CXXFLAGS=	$(CFLAGS)
+LDFLAGS=	
+OBJS=		
+LIBS=		
+
+all: run
+
+udb2:
+	git clone https://github.com/attractivechaos/udb2.git
+
+build: udb2
+	mkdir -p udb2/mlib
+	cp test-mlib.c udb2/mlib/test.c
+	cp Makefile-mlib udb2/mlib/Makefile
+	touch build
+
+all-recur: build
+	cd udb2/stb && make CC="gcc -lm"
+	cd udb2 && for dir in `ls | egrep -v '^(Makefile|common.c|_)'`; do cd $$dir && make && cd -; done
+
+run: all-recur
+	@cd udb2;						\
+	echo ;	echo RUNNING BENCH ; echo ;			\
+	for i in `find . -name 'run-test'` ; do			\
+	    echo ; echo `dirname $$i|sed -e 's+./++g'`;		\
+	    $$i ;						\
+	done
+
+clean:
+	rm -rf udb2 build *~

bench/udb2/Makefile-mlib

@@ -0,0 +1,8 @@
+all:run-test
+
+run-test:test.c ../common.c
+	$(CC) -std=gnu99 -O2 -Wall -I../../../.. $< -o $@
+
+clean:
+	rm -f run-test* *~
+	rm -rf mlib

bench/udb2/test-mlib.c

@@ -0,0 +1,34 @@
+#include "../common.c"
+#define DICTI_OA_PROBING(s) 1
+#include "m-dict.h"
+
+static inline bool oor_equal_p(unsigned int k, unsigned char n)
+{
+  return k == (unsigned int)n;
+}
+static inline void oor_set(unsigned int *k, unsigned char n)
+{
+  *k = (unsigned int)n;
+}
+
+DICT_OA_DEF2(dict_oa_uint,
+	     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)
+
+uint32_t test_int(uint32_t n, uint32_t x0)
+{
+  uint32_t i, x, z = 0;
+  dict_oa_uint_t h;
+  dict_oa_uint_init(h);
+  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_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;
+}

doc/API.txt

@@ -0,0 +1,47 @@
+API incompatibility
+-------------------
+
+V0.1.*: * First formal version of API
+
+V0.2.*: * worker_start takes a 'worker_t' as an additional parameter
+	(This enables to perform a wait-on-event instead of a busy waiting).
+        * worker_spawn doesn't take into a 'worker_t' anymore.
+	* worker_init takes an int as numWorker instead of an unsigned int.
+	* RBTREE pop method has been renamed into _pop_at (as it takes a key parameter).
+        * SNAPSHOT_DEF has been removed. use SNAPSHOT_SPSC_DEF
+        * array's _set_at2 has been replaced by array's _get_at.
+        The interface is similar to dict _get_at, making the API cleaner and more generic.
+            _set_at2(a,i,x) ==> set(*_get_at(a,i),x)
+        * DICT_SET:
+          - Rename method _set_at as _push
+        Since there is no key, it is a push method, not a _set_at method.
+          - Rename DICT_SET_DEF2 as DICT_SET_DEF
+        since it only requires one argument.
+          - The method _ref returns a pointer to the data,
+        instead of a pointer to a single tuple like other DICT_SET interface.
+          - The format of the output to character string as changed. 
+        * ALGO:
+          - Rename _contains as _contain_p
+        since it is a predicate '_p' and it shall be in infinitive form.
+          - Rename _map as _for_each (Standard name).
+        * M_PRINT_ARG & M_FPRINT_ARG don't put a final semicolon at the end
+        of their expansion anymore (cleaner and no longer needed with the
+        new available tools).
+        * For the TUPLE and the VARIANT
+        change name of _get_ ## field into _get_at_ ## fields
+        Since there is a name collision with other methods
+        if a field is named 'str'.
+        * Rename method _remove into _erase for dictionary & B+TREE (adding a compatibility layer) for API uniformization.
+        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).

doc/Container.html

@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN" "http://www.w3.org/Math/DTD/mathml2/xhtml-math11-f.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><!--This file was converted to xhtml by LibreOffice - see http://cgit.freedesktop.org/libreoffice/core/tree/filter/source/xslt for the code.--><head profile="http://dublincore.org/documents/dcmi-terms/"><meta http-equiv="Content-Type" content="application/xhtml+xml; charset=utf-8"/><title xml:lang="en-US">- no title specified</title><meta name="DCTERMS.title" content="" xml:lang="en-US"/><meta name="DCTERMS.language" content="en-US" scheme="DCTERMS.RFC4646"/><meta name="DCTERMS.source" content="http://xml.openoffice.org/odf2xhtml"/><meta name="DCTERMS.issued" content="2018-07-01T11:06:00.978729880" scheme="DCTERMS.W3CDTF"/><meta name="DCTERMS.provenance" content="" xml:lang="en-US"/><meta name="DCTERMS.subject" content="," xml:lang="en-US"/><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/" hreflang="en"/><link rel="schema.DCTERMS" href="http://purl.org/dc/terms/" hreflang="en"/><link rel="schema.DCTYPE" href="http://purl.org/dc/dcmitype/" hreflang="en"/><link rel="schema.DCAM" href="http://purl.org/dc/dcam/" hreflang="en"/><style type="text/css">
+	@page {  }
+	table { border-collapse:collapse; border-spacing:0; empty-cells:show }
+	td, th { vertical-align:top; font-size:10pt;}
+	h1, h2, h3, h4, h5, h6 { clear:both }
+	ol, ul { margin:0; padding:0;}
+	li { list-style: none; margin:0; padding:0;}
+	<!-- "li span.odfLiEnd" - IE 7 issue-->
+	li span. { clear: both; line-height:0; width:0; height:0; margin:0; padding:0; }
+	span.footnodeNumber { padding-right:1em; }
+	span.annotation_style_by_filter { font-size:95%; font-family:Arial; background-color:#fff000;  margin:0; border:0; padding:0;  }
+	* { margin:0;}
+	.ta1 { writing-mode:lr-tb; }
+	.Default { font-family:Liberation Sans; }
+	.ce100 { font-family:Liberation Sans; border-bottom-width:0,0621cm; border-bottom-style:solid; border-bottom-color:#000000; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-style:none; text-align:center ! important; margin-left:0cm; }
+	.ce101 { font-family:Liberation Sans; border-bottom-style:none; background-color:#ffff00; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-style:none; text-align:center ! important; margin-left:0cm; }
+	.ce102 { font-family:Liberation Sans; border-bottom-width:0,0621cm; border-bottom-style:solid; border-bottom-color:#000000; background-color:#ffff00; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-style:none; text-align:center ! important; margin-left:0cm; }
+	.ce103 { font-family:Liberation Sans; border-bottom-style:none; background-color:#ffff00; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-width:0,0621cm; border-top-style:solid; border-top-color:#000000; text-align:center ! important; margin-left:0cm; }
+	.ce104 { font-family:Liberation Sans; background-color:#e6e6e6; font-size:11pt; text-decoration:underline; font-weight:bold; }
+	.ce57 { font-family:Liberation Sans; background-color:transparent; font-size:11pt; text-decoration:none ! important; font-weight:bold; }
+	.ce58 { font-family:Liberation Sans; border-bottom-width:0,0621cm; border-bottom-style:solid; border-bottom-color:#000000; background-color:transparent; border-left-style:none; border-right-style:none; border-top-style:none; font-size:11pt; text-decoration:none ! important; font-weight:bold; }
+	.ce59 { font-family:Liberation Sans; border-bottom-style:none; background-color:#e6e6e6; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-style:none; border-top-width:0,0621cm; border-top-style:solid; border-top-color:#000000; font-size:11pt; text-decoration:underline; font-weight:bold; }
+	.ce60 { font-family:Liberation Sans; border-bottom-style:none; background-color:#e6e6e6; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-style:none; border-top-style:none; font-size:11pt; text-decoration:none ! important; font-weight:bold; }
+	.ce61 { font-family:Liberation Sans; border-bottom-width:0,0621cm; border-bottom-style:solid; border-bottom-color:#000000; background-color:#e6e6e6; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-style:none; border-top-style:none; font-size:11pt; text-decoration:none ! important; font-weight:bold; }
+	.ce62 { font-family:Liberation Sans; background-color:#e6e6e6; font-size:11pt; text-decoration:none ! important; font-weight:bold; }
+	.ce63 { font-family:Liberation Sans; background-color:#e6e6e6; border-width:0,0621cm; border-style:solid; border-color:#000000; text-align:center ! important; margin-left:0cm; font-size:11pt; font-weight:bold; }
+	.ce64 { font-family:Liberation Sans; border-bottom-style:none; background-color:#e6e6e6; border-left-style:none; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-width:0,0621cm; border-top-style:solid; border-top-color:#000000; font-weight:bold; }
+	.ce65 { font-family:Liberation Sans; border-bottom-style:none; background-color:#e6e6e6; border-left-style:none; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-style:none; font-weight:bold; }
+	.ce66 { font-family:Liberation Sans; border-bottom-width:0,0621cm; border-bottom-style:solid; border-bottom-color:#000000; background-color:#e6e6e6; border-left-style:none; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-style:none; font-weight:bold; }
+	.ce67 { font-family:Liberation Sans; border-bottom-style:none; background-color:#e6e6ff; border-left-style:none; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-style:none; font-weight:bold; }
+	.ce68 { font-family:Liberation Sans; border-bottom-width:0,0621cm; border-bottom-style:solid; border-bottom-color:#000000; background-color:#e6e6ff; border-left-style:none; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-style:none; font-weight:bold; }
+	.ce69 { font-family:Liberation Sans; border-bottom-style:none; background-color:#e6e6ff; border-left-style:none; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-width:0,0621cm; border-top-style:solid; border-top-color:#000000; font-weight:bold; }
+	.ce70 { font-family:Liberation Sans; background-color:#e6e6e6; font-weight:bold; }
+	.ce71 { font-family:Liberation Sans; border-bottom-style:none; background-color:#e6e6e6; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-width:0,0621cm; border-top-style:solid; border-top-color:#000000; text-align:center ! important; margin-left:0cm; font-size:11pt; text-decoration:underline; font-weight:bold; }
+	.ce72 { font-family:Liberation Sans; border-bottom-width:0,0621cm; border-bottom-style:solid; border-bottom-color:#000000; background-color:#e6e6e6; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-style:none; border-top-style:none; text-align:center ! important; margin-left:0cm; font-weight:bold; }
+	.ce73 { font-family:Liberation Sans; border-bottom-style:none; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-style:none; border-top-width:0,0621cm; border-top-style:solid; border-top-color:#000000; text-align:center ! important; margin-left:0cm; }
+	.ce74 { font-family:Liberation Sans; border-bottom-style:none; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-style:none; border-top-style:none; text-align:center ! important; margin-left:0cm; }
+	.ce75 { font-family:Liberation Sans; border-bottom-width:0,0621cm; border-bottom-style:solid; border-bottom-color:#000000; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-style:none; border-top-style:none; text-align:center ! important; margin-left:0cm; }
+	.ce76 { font-family:Liberation Sans; border-bottom-style:none; background-color:transparent; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-style:none; border-top-style:none; text-align:center ! important; margin-left:0cm; }
+	.ce77 { font-family:Liberation Sans; text-align:center ! important; margin-left:0cm; }
+	.ce78 { font-family:Liberation Sans; border-bottom-style:none; background-color:#e6e6e6; border-left-style:none; border-right-style:none; border-top-width:0,0621cm; border-top-style:solid; border-top-color:#000000; text-align:center ! important; margin-left:0cm; font-size:11pt; text-decoration:underline; font-weight:bold; }
+	.ce79 { font-family:Liberation Sans; border-bottom-width:0,0621cm; border-bottom-style:solid; border-bottom-color:#000000; background-color:#e6e6e6; border-left-style:none; border-right-style:none; border-top-style:none; text-align:center ! important; margin-left:0cm; font-weight:bold; }
+	.ce80 { font-family:Liberation Sans; border-bottom-style:none; border-left-style:none; border-right-style:none; border-top-width:0,0621cm; border-top-style:solid; border-top-color:#000000; text-align:center ! important; margin-left:0cm; }
+	.ce81 { font-family:Liberation Sans; border-bottom-width:0,0621cm; border-bottom-style:solid; border-bottom-color:#000000; border-left-style:none; border-right-style:none; border-top-style:none; text-align:center ! important; margin-left:0cm; }
+	.ce82 { font-family:Liberation Sans; background-color:transparent; text-align:center ! important; margin-left:0cm; }
+	.ce83 { font-family:Liberation Sans; border-bottom-width:0,0621cm; border-bottom-style:solid; border-bottom-color:#000000; background-color:transparent; border-left-style:none; border-right-style:none; border-top-style:none; text-align:center ! important; margin-left:0cm; }
+	.ce84 { font-family:Liberation Sans; background-color:#ffff00; text-align:center ! important; margin-left:0cm; }
+	.ce85 { font-family:Liberation Sans; border-bottom-width:0,0621cm; border-bottom-style:solid; border-bottom-color:#000000; background-color:#ffff00; border-left-style:none; border-right-style:none; border-top-style:none; text-align:center ! important; margin-left:0cm; }
+	.ce86 { font-family:Liberation Sans; border-bottom-style:none; background-color:#ffff00; border-left-style:none; border-right-style:none; border-top-width:0,0621cm; border-top-style:solid; border-top-color:#000000; text-align:center ! important; margin-left:0cm; }
+	.ce87 { font-family:Liberation Sans; border-bottom-style:none; background-color:#e6e6e6; border-left-style:none; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-width:0,0621cm; border-top-style:solid; border-top-color:#000000; text-align:center ! important; margin-left:0cm; font-size:11pt; text-decoration:underline; font-weight:bold; }
+	.ce88 { font-family:Liberation Sans; border-bottom-width:0,0621cm; border-bottom-style:solid; border-bottom-color:#000000; background-color:#e6e6e6; border-left-style:none; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-style:none; text-align:center ! important; margin-left:0cm; font-weight:bold; }
+	.ce89 { font-family:Liberation Sans; border-bottom-style:none; border-left-style:none; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-width:0,0621cm; border-top-style:solid; border-top-color:#000000; text-align:center ! important; margin-left:0cm; }
+	.ce90 { font-family:Liberation Sans; border-bottom-style:none; border-left-style:none; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-style:none; text-align:center ! important; margin-left:0cm; }
+	.ce91 { font-family:Liberation Sans; border-bottom-width:0,0621cm; border-bottom-style:solid; border-bottom-color:#000000; border-left-style:none; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-style:none; text-align:center ! important; margin-left:0cm; }
+	.ce92 { font-family:Liberation Sans; border-bottom-style:none; background-color:#ffff00; border-left-style:none; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-style:none; text-align:center ! important; margin-left:0cm; }
+	.ce93 { font-family:Liberation Sans; border-bottom-style:none; background-color:#ffff00; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-style:none; border-top-style:none; text-align:center ! important; margin-left:0cm; }
+	.ce94 { font-family:Liberation Sans; border-bottom-style:none; background-color:transparent; border-left-style:none; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-style:none; text-align:center ! important; margin-left:0cm; }
+	.ce95 { font-family:Liberation Sans; border-bottom-width:0,0621cm; border-bottom-style:solid; border-bottom-color:#000000; background-color:transparent; border-left-style:none; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-style:none; text-align:center ! important; margin-left:0cm; }
+	.ce96 { font-family:Liberation Sans; border-bottom-style:none; background-color:#e6e6e6; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-width:0,0621cm; border-top-style:solid; border-top-color:#000000; text-align:center ! important; margin-left:0cm; font-size:11pt; text-decoration:none ! important; font-weight:bold; }
+	.ce97 { font-family:Liberation Sans; border-bottom-width:0,0621cm; border-bottom-style:solid; border-bottom-color:#000000; background-color:#e6e6e6; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-style:none; text-align:center ! important; margin-left:0cm; font-weight:bold; }
+	.ce98 { font-family:Liberation Sans; border-bottom-style:none; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-width:0,0621cm; border-top-style:solid; border-top-color:#000000; text-align:center ! important; margin-left:0cm; }
+	.ce99 { font-family:Liberation Sans; border-bottom-style:none; border-left-width:0,0621cm; border-left-style:solid; border-left-color:#000000; border-right-width:0,0621cm; border-right-style:solid; border-right-color:#000000; border-top-style:none; text-align:center ! important; margin-left:0cm; }
+	.co1 { width:3.399cm; }
+	.co10 { width:1.304cm; }
+	.co11 { width:1.942cm; }
+	.co12 { width:1.815cm; }
+	.co13 { width:1.348cm; }
+	.co14 { width:1.432cm; }
+	.co15 { width:2.258cm; }
+	.co2 { width:6.281cm; }
+	.co3 { width:1.475cm; }
+	.co4 { width:1.277cm; }
+	.co5 { width:1.602cm; }
+	.co6 { width:1.39cm; }
+	.co7 { width:1.686cm; }
+	.co8 { width:1.644cm; }
+	.co9 { width:2.452cm; }
+	.ro1 { height:0.487cm; }
+	.ro2 { height:0.885cm; }
+	.ro3 { height:0.452cm; }
+	<!-- ODF styles with no properties representable as CSS -->
+	 { }
+	</style></head><body dir="ltr" style="writing-mode:lr-tb; "><table border="0" cellspacing="0" cellpadding="0" class="ta1"><colgroup><col width="149"/><col width="274"/><col width="64"/><col width="56"/><col width="70"/><col width="61"/><col width="74"/><col width="72"/><col width="107"/><col width="57"/><col width="107"/><col width="107"/><col width="74"/><col width="85"/><col width="79"/><col width="79"/><col width="59"/><col width="61"/><col width="63"/><col width="99"/></colgroup><tr class="ro1"><td style="text-align:left;width:3.399cm; " class="ce57"> </td><td style="text-align:left;width:6.281cm; " class="ce57"> </td><td colspan="6" style="text-align:left;width:1.475cm; " class="ce71"><p>Sequence Containers</p></td><td colspan="4" style="text-align:left;width:2.452cm; " class="ce71"><p>Associative Containers</p></td><td style="text-align:left;width:1.686cm; " class="ce96"> </td><td colspan="6" style="text-align:left;width:1.942cm; " class="ce71"><p>Synchronization Containers</p></td><td style="text-align:left;width:2.258cm; " class="ce104"> </td></tr><tr class="ro2"><td style="text-align:left;width:3.399cm; " class="ce58"> </td><td style="text-align:left;width:6.281cm; " class="ce63"><p>Method</p></td><td style="text-align:left;width:1.475cm; " class="ce72"><p>ARRAY</p></td><td style="text-align:left;width:1.277cm; " class="ce79"><p>LIST</p></td><td style="text-align:left;width:1.602cm; " class="ce79"><p>DUALP</p><p>LIST</p></td><td style="text-align:left;width:1.39cm; " class="ce79"><p>I-LIST</p></td><td style="text-align:left;width:1.686cm; " class="ce79"><p>DEQUE</p></td><td style="text-align:left;width:1.644cm; " class="ce88"><p>BITSET</p></td><td style="text-align:left;width:2.452cm; " class="ce72"><p>B+TREE</p><p>DICT/SET</p></td><td style="text-align:left;width:1.304cm; " class="ce79"><p>R/B</p><p>TREE</p></td><td style="text-align:left;width:2.452cm; " class="ce79"><p>[S]HASH</p><p>DICT / SET</p></td><td style="text-align:left;width:2.452cm; " class="ce88"><p>OA DICT</p></td><td style="text-align:left;width:1.686cm; " class="ce97"><p>PRIO </p><p>QUEUE</p></td><td style="text-align:left;width:1.942cm; " class="ce72"><p>BUFFER</p></td><td style="text-align:left;width:1.815cm; " class="ce79"><p>QUEUE </p><p>MPMC</p></td><td style="text-align:left;width:1.815cm; " class="ce79"><p>QUEUE </p><p>SPSC</p></td><td style="text-align:left;width:1.348cm; " class="ce79"><p>SNAP</p><p>SPSC</p></td><td style="text-align:left;width:1.39cm; " class="ce79"><p>SNAP</p><p>SPMC</p></td><td style="text-align:left;width:1.432cm; " class="ce88"><p>SNAP </p><p>MPMC</p></td><td style="text-align:left;width:2.258cm; " class="ce70"> </td></tr><tr class="ro1"><td style="text-align:left;width:3.399cm; " class="ce59"><p>CONSTRUCTOR</p></td><td style="text-align:left;width:6.281cm; " class="ce64"><p>_init</p></td><td style="text-align:left;width:1.475cm; " class="ce73"><p>X</p></td><td style="text-align:left;width:1.277cm; " class="ce80"><p>X</p></td><td style="text-align:left;width:1.602cm; " class="ce80"><p>X</p></td><td style="text-align:left;width:1.39cm; " class="ce80"><p>X</p></td><td style="text-align:left;width:1.686cm; " class="ce80"><p>X</p></td><td style="text-align:left;width:1.644cm; " class="ce89"><p>X</p></td><td style="text-align:left;width:2.452cm; " class="ce73"><p>X</p></td><td style="text-align:left;width:1.304cm; " class="ce80"><p>X</p></td><td style="text-align:left;width:2.452cm; " class="ce80"><p>X</p></td><td style="text-align:left;width:2.452cm; " class="ce89"><p>X</p></td><td style="text-align:left;width:1.686cm; " class="ce98"><p>X</p></td><td style="text-align:left;width:1.942cm; " class="ce73"><p>X</p></td><td style="text-align:left;width:1.815cm; " class="ce80"><p>X</p></td><td style="text-align:left;width:1.815cm; " class="ce80"><p>X</p></td><td style="text-align:left;width:1.348cm; " class="ce80"><p>X</p></td><td style="text-align:left;width:1.39cm; " class="ce80"><p>X</p></td><td style="text-align:left;width:1.432cm; " class="ce89"><p>X</p></td><td style="text-align:left;width:2.258cm; " class="Default"> </td></tr><tr class="ro1"><td style="text-align:left;width:3.399cm; " class="ce60"> </td><td style="text-align:left;width:6.281cm; " class="ce65"><p>_set</p></td><td style="text-align:left;width:1.475cm; " class="ce74"><p>X</p></td><td style="text-align:left;width:1.277cm; " class="ce77"><p>X</p></td><td style="text-align:left;width:1.602cm; " class="ce77"><p>X</p></td><td style="text-align:left;width:1.39cm; " class="ce77"> </td><td style="text-align:left;width:1.686cm; " class="ce77"><p>X</p></td><td style="text-align:left;width:1.644cm; " class="ce90"><p>X</p></td><td style="text-align:left;width:2.452cm; " class="ce74"><p>X</p></td><td style="text-align:left;width:1.304cm; " class="ce77"><p>X</p></td><td style="text-align:left;width:2.452cm; " class="ce77"><p>X</p></td><td style="text-align:left;width:2.452cm; " class="ce90"><p>X</p></td><td style="text-align:left;width:1.686cmLine truncated

doc/DEV.md

@@ -2,39 +2,100 @@ How to make a release?
 ======================
 
 1) Check that all test pass on all primary systems.
-   Run 'make check' on all primary systems.
+   Run 'make check' or 'make checkall' on all primary systems.
    No error shall be reported.
    
-2) Check that no memory leak is reported by valgrind:
-   Run 'make valgrind' in tests folder on a system.
-   NOTE: valgrind seems completly lost in all the tests which spawn a lot of threads.
-   
-3) Check that no undefined behavior, nor data race, ... is reported by sanitizer:
+2) Check that no undefined behavior, nor data race, ... is reported by sanitizer:
    Run 'make sanitize'  in tests folder on a system.
    This needs at least GCC 7
 
-4) Check that no new warning is reported by static analyser:
-   Run 'make scan-build' in tests folder on a system.
-   This needs at least clang 4.
-   Currently there is a false positive detected in m-shared:
-   "Argument to free() is offset by 8 bytes from the start of memory allocated by malloc()"
-   scan-build is not able to properly track that this case cannot open.
-   
-5) Check that coverage is reasonnable.
+3) Check that coverage is reasonable.
    Run 'make coverage' and analyze result.
 
-6) Publish the release
+4) Publish the release
 
 In case of problem, open a problem report.
 
-List of primary systems
+
+List of tested systems
 =======================
 
-* gcc 4.9 on linux/x86-64
-* gcc 7 on linux/x86-64
-* clang 3.5 on linux/x86-64
-* clang 4 on linux/x86-64
-* g++ 7 on linux/x86-64
+* 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
 * tcc on linux/x86-64
-* gcc 6 on windows/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
 
+
+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
+command. It performs a cross-compilation of the test suite from linux to windows
+and run the test suite with wine:
+
+        make CC="i586-mingw32msvc-gcc -std=c99 -DWINVER=0x600 -D_WIN32_WINNT=0x600" LOG_COMPILER=wine check
+
+
+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:
+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.
+
+The original issue in the tracker can then be closed with the issuer agreement.
+
+This will have the following gains:
+
+- no hard dependencies on any bug tracking infrastructure (can be migrated easily). 
+- a release will automatically contain all its open problem reports.
+
+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:
+
+          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

doc/ISSUES.org

@@ -0,0 +1,395 @@
+
+*Long term issues*
+------------------
+
+* TODO #26 : Hash-Map for huge objects                          :ENHANCEMENT:
+
+Specialize Hashmap for huge objects on supported hardware:
+
+
+based on OA hash map of taggued pointer (needs space for tagging)
+low bits = low bits of hash
+pointer to object { key, hash, value }
+
+Can detect collision without dereferencing object with 1/2^lowbits chances.
+Reduce cache usage ==> Shall be faster.
+
+Use of pointer to avoid moving object on GC.
+
+
+* TODO #25 : Support of error code 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".
+==> 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.
+
+New operator: ERROR_MODEL which value is 0 (abort on error), 1 (throw on error)
+or 2 (return code on error).
+
+Find a way to make it while not making the code too complex 
+(try to keep as simple as possible).
+
+
+* TODO #24 : Add 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: Force MOVE semantic                                 :ENHANCEMENT:
+
+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                                               :ENHANCEMENT:
+
+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.
+
+
+* TODO #20: Bucket priority queue                               :ENHANCEMENT:
+
+Add a new kind of priority queue. 
+See https://en.wikipedia.org/wiki/Bucket_queue
+
+Check if it will be better as intrusive or non-intrusive container.
+
+To test if a bucket is empty or not, a bitfield can be used to check if
+the bit associated to the bucket is set or not. To get the highest bucket
+non empty, we can perform a CLZ of the bitset, which shall be much faster than
+performing a linear search of the buckets (algorithm complexity is the same,
+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:
+
+ Add intrusive red black tree. 
+ Look also for AVL tree (NOTE: Is there a performance difference between the two?)
+
+
+* 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: Ressource handler                                   :ENHANCEMENT:
+
+ A 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
+ until 585 years).
+
+ The ressource handler shall make an association between a HANDLE 64 bits and:
+
+- how much real owners claim to own the ressource
+ (the ressource is only owned by the ressource handler, however
+  it acts as a delegate of the real owner),
+- how much users keep a pointer to the ressource.
+- pointer to the resource itself.
+
+ This may be a better alternative than shared_ptr & weak_ptr:
+
+- reduce fragmentation,
+- no cycle dependencies,
+- shared_ref & weak_ref becomes only HANDLE,
+- all ressources can be freed in one pass.
+ 
+ Needs lock free dictionnary or at least concurrent dictionnary.
+
+ 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.
+
+
+* TODO #16: 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.
+
+** First  step: backoff methods                                        :DONE:
+** Second step: lock free node pool :                                  :DONE:
+   Done as m-c-mempool header.
+
+** Third  step: Implement generic lock free list on top of it.
+
+ The ABA problem is already taken into account by the memory alloctor
+ provided that the lock free list doesn't try to be smart.
+
+ backoff has be used when using CAS.
+ 
+ Concurrent insertion / insertion and insertion / deletion and deletion / deletion shall be crefully analyzed when 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
+
+
+* TODO #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?)
+
+
+* TODO #14: Memory allocation enhancement                       :ENHANCEMENT:
+
+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),
+-  expected life of created type (temporary or permanent),
+-  stack based allocator,
+-  global variable access for allocator,
+-  maximum allocation before failure.
+
+Most of theses are already more or less supported. Examples shall be created to show how to deal with this:
+
+- alignement shall be implemented with the attributes of <stdalign.h>
+
+However I sill don't know how to implement "instance-based allocator" which is what is missing.
+The problem is how to give to methods context local information store within the container itself.
+
+Update:
+
+API transformation support enables "instance-based allocator" to be made easily.
+Needs some formal operator in the oplist to support it fully and an example.
+
+ Can be supported using another API extension, some more operators and forcing some names:
+
+ * API_N: call like FUNC(obj->extra_data, type)
+
+ 'obj' is a forced named corresponding to an alias to an object in the function.
+ Operator needed:
+  
+ - 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.
+
+
+* TODO #12: Atomic shared pointer                               :ENHANCEMENT:
+
+Add an extension to the SHARED_PTR API:
+
+- New type atomic_shared_ptr
+- name_init_atomic_set (&atomic_shared_ptr, shared_ptr);
+- name_init_set_atomic (shared_ptr, &atomic_shared_ptr);
+- name_init_atomic_set_atomic (&atomic_shared_ptr, &atomic_shared_ptr);
+- name_atomic_set (&atomic_shared_ptr, shared_ptr);
+- name_set_atomic (shared_ptr, &atomic_shared_ptr);
+- name_atomic_set_atomic (&atomic_shared_ptr, &atomic_shared_ptr);
+- name_atomic_clear
+
+No _ref or direct _init: we need to init first a normal shared_ptr then the atomic (TBC)
+
+** _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 like a normal shared pointer.
+All 3 steps are safe.
+
+** _set_atomic method:
+
+It needs to perform the following atomic operation : <read the pointer, deref pointer and increment the pointed value> I don't known how to do it properly.
+
+See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4162.pdf
+
+Proposition for _set_atomic we store temporary NULL to the atomic_ptr struct to request an exclusive access to the data (this looks like a lock and other operations need to handle NULL) :
+
+#+BEGIN_SRC C
+        void shared_ptr_set_atomic(ptr a, atomic_ptr *ptr)
+        {
+          // Get exclusive access to the data
+          p = atomic_load(ptr);
+          do {
+            if (p == NULL) {
+              // TODO: exponential backoff
+              p = atomic_load(ptr);
+              continue;
+            }
+          } while (!atomic_compare_exchange_weak(ptr, &p, NULL));
+          // p has exclusive access to the pointer
+          p->data->cpt ++;
+          a->data = p->data;
+          atomic_exchange (ptr, p);
+        }
+#+END_SRC
+
+This prevents using NULL which obliges atomic shared pointer to point to a created object...
+
+Other alternative solution is to use the bit 0 to mark the pointer as being updated, preventing other from using it (TBC only clear):
+
+#+BEGIN_SRC C
+        void shared_ptr_set_atomic(ptr a, atomic_ptr *ptr)
+        {
+          // Get exclusive access to the data
+          p = atomic_load(ptr);
+          do {
+            if ( (p&1) != 0) {
+              // TODO: exponential backoff
+              p = atomic_load(ptr);
+              continue;
+            }
+          } while (!atomic_compare_exchange_weak(ptr, &p, p|1));
+         // Exclusive access (kind of lock).
+          p->data->cpt ++;
+          a->data = p->data;
+          atomic_set (ptr, p);
+        }
+#+END_SRC
+
+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:
+
+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
+
+** Multiple locks within the dictionnary
+
+A potential implementation may be to request at initialization time the number of concurrent thread N.
+Create a static array of N dictionnary with N mutex. Then to access the data will perform :
+
+- compute hash of object,
+- access high bits of hash and select which dictionnary shall have the data,
+- lock it,
+- perform classic access to the data (check if the compiler can properly optimize the hash computation),
+- unlock it.
+
+The property of the hash shall allow a good dispersion of the data across multiple locks, reducing the constraints on the lock. This implementation could be build easily upon the already existent dictionary.
+
+To test.
+
+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 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).
+
+* 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.
+
+
+
+

example/Makefile

@@ -1,18 +1,25 @@
 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 -Winline -Wundef -Wnested-externs -Wcast-qual -Wshadow -Wunreachable-code -Wlogical-op -Wstrict-aliasing=2 -Wredundant-decls -Wold-style-definition -Wno-unused-function -g
+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) $(LDFLAGS) `cat config` $< -o $@
 
-all:
+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
+
+config:
+	printf "#include <gmp.h>\nint main(void){mpz_t z; mpz_init(z); return 0;}\n" > config-test.c
+	$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS)  -I$(GMP_DIR)/include -L$(GMP_DIR)/lib -lgmp config-test.c -o config-test.exe 2> /dev/null && echo "-DHAVE_GMP=1  -I$(GMP_DIR)/include -L$(GMP_DIR)/lib -lgmp" > config || echo "-DHAVE_GMP=0" > config
+	$(RM) config-test.c config-test.exe
 
 clean:
-	$(RM) *.exe *.s *~ *.o ./a.dat
+	$(RM) *.exe *.s *~ *.o ./a.dat config
 
 

example/ex-algo02.c

@@ -0,0 +1,53 @@
+#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)
+ALGO_DEF(vector_int, vector_int_t)
+
+/* Define a dynamic array of bool */ 
+ARRAY_DEF(vector_bool, bool)
+#define M_OPL_vector_bool_t() ARRAY_OPLIST(vector_bool)
+ALGO_DEF(vector_bool, vector_bool_t)
+
+static bool id(bool x) { return x ; }
+
+int main(void)
+{
+  M_LET(myvector, tmp, vector_int_t) {
+    vector_int_fill_n(myvector, 3, 20);
+    vector_int_fill_n(tmp, 3, 33);
+    vector_int_splice(myvector, tmp);
+    vector_int_fill_n(tmp, 2, 10);
+    vector_int_splice(myvector, tmp);
+    printf("myvector contains:");
+    // In C11, the for loop can be simplified as :
+    // ALGO_FOR_EACH(myvector, vector_int_t, M_PRINT, " ");
+    for M_EACH(it, myvector, vector_int_t) {
+        printf(" %d", *it);
+      }
+    printf("\n");
+  }
+  
+  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:");
+    // In C11, the for loop can be simplified as :
+    // ALGO_FOR_EACH(myvector, vector_bool_t, M_PRINT, " ");
+    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) );
+  }
+  return 0;
+}

example/ex-algo03.c

@@ -0,0 +1,31 @@
+#include "m-dict.h"
+#include "m-array.h"
+#include "m-algo.h"
+#include "m-string.h"
+
+DICT_DEF2(dict, string_t, int)
+#define M_OPL_dict_t() DICT_OPLIST(dict, STRING_OPLIST, M_DEFAULT_OPLIST)
+
+ARRAY_DEF(vector_int, int)
+#define M_OPL_vector_int_t() ARRAY_OPLIST(vector_int)
+
+#define start_with(pattern, item)                \
+  string_start_with_str_p((item).key, (pattern))
+#define get_value(out, item) ((out) = (item).value)
+
+int main(void)
+{
+  int s;
+  M_LET(keys, vector_int_t)
+    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' */
+    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;
+}

example/ex-algo04.c

@@ -0,0 +1,27 @@
+#include "m-algo.h"
+#include "m-array.h"
+#include "m-string.h"
+
+ARRAY_DEF(vector_int, int)
+#define M_OPL_vector_int_t() ARRAY_OPLIST(vector_int)
+
+#define str_ui(s, i) string_printf(s, "%d", i)
+#define str_cat(s1, s2) (string_cat_str(s1, "-"), string_cat(s1, s2))
+
+int main(void)
+{
+  M_LET(s, string_t)
+    M_LET( (v, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10), vector_int_t) {
+    int sum, product;
+    
+    ALGO_REDUCE(sum, v, vector_int_t, add);
+    ALGO_REDUCE(product, v, vector_int_t, mul);
+    /* Example of reduction with a transformation of the type from int to string_t */
+    ALGO_REDUCE( (s, string_t), v, vector_int_t, str_cat, str_ui);
+
+    printf ("sum: %d\n"
+            "product: %d\n"
+            "dash str: %s\n", sum, product, string_get_cstr(s));
+  }
+  return 0;
+}

example/ex-array00.c

@@ -0,0 +1,619 @@
+/* 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_DEFAULT_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_DEFAULT_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_DEFAULT_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 string.
+   We *** need *** an explicit oplist to tell M*LIB
+   to consider the type as a constant 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[10];
+    // 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 integer
+    int j = atoi(p);
+    s += j;
+  }
+
+  // We also need a special unalloc pass
+  // to free all constant strings we have allocated.
+  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 variable 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_printf(str, "%d", 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 dealloc !
+  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. And 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.
+    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;
+    // 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;
+    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;
+    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_DEFAULT_OPLIST is used.
+
+   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.
+ */
+TUPLE_DEF2(rock_you, (n, int), (other, float))
+
+ARRAY_DEF(r_rockme3, rock_you_t, TUPLE_OPLIST(rock_you, M_DEFAULT_OPLIST, M_DEFAULT_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_DEFAULT_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_DEFAULT_OPLIST, M_DEFAULT_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_rockme3(n);
+  printf ("S[rockme4] = %d\n", s);
+
+  exit(0);
+}

example/ex-array04.c

@@ -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

example/ex-array05.c

@@ -0,0 +1,116 @@
+#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.
+*/
+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);
+}

example/ex-bptree01.c

@@ -0,0 +1,60 @@
+#include "m-bptree.h"
+#include "m-string.h"
+
+// Define a map int -> string
+BPTREE_DEF2(map_employee_id, 5, int, string_t)
+#define M_OPL_map_employee_id_t() BPTREE_OPLIST2(map_employee_id, M_DEFAULT_OPLIST, STRING_OPLIST)
+
+// Define a map string -> int
+BPTREE_DEF2(map_employee_name, 5, string_t, int)
+#define M_OPL_map_employee_name_t() BPTREE_OPLIST2(map_employee_name, STRING_OPLIST, M_DEFAULT_OPLIST)
+
+int main(void)
+{
+  map_employee_id_t Employees;
+  map_employee_id_init(Employees);
+
+  // Assign
+  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"));
+  map_employee_id_set_at(Employees, 4258, STRING_CTE("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_type_t *e = map_employee_id_cref(it);
+    // Print it
+    printf ("%d: %s\n", *(e->key_ptr), string_get_cstr(*(e->value_ptr)));
+  }
+
+  // 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")));
+    
+  }
+
+  map_employee_id_clear(Employees);
+  return 0;
+}

example/ex-dict02.c

@@ -15,7 +15,7 @@ int main(void) {
   char *k = dict_m32_get(h, 10);            // No 10 in h, so k == NULL
   int is_missing = (k != NULL);             // true
   assert (is_missing);
-  dict_m32_remove(h, 5);                    // h is now empty
+  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)) {
     struct dict_m32_pair_s *item = dict_m32_ref(it);
@@ -33,7 +33,7 @@ int main(void) {
     char *k = dict_m32_get(h, 10);            // k == NULL
     int is_missing = (k != NULL);             // true
     assert (is_missing);
-    dict_m32_remove(h, 5);                    // h is now empty
+    dict_m32_erase(h, 5);                    // h is now empty
     for M_EACH(item, h, M32_OPLIST) {         // traverse each item
         item->value = 1;                      // Set its value to 1
       }

example/ex-dict03.c

@@ -50,11 +50,11 @@ int main(void)
           printf("Enter the mapped string to be deleted: ");
           string_fgets (str, stdin, STRING_READ_PURE_LINE);
           s = atoi(string_get_cstr(str));
-          dict_map_remove(mp, s);
+          dict_map_erase(mp, s);
           break;
 
         case 3:
-          printf("Size of Map: %lu\n", (unsigned long) dict_map_size(mp) );
+          printf("Size of Map: %zu\n", dict_map_size(mp) );
           break;
 
         case 4:

example/ex-dict04.c

@@ -5,14 +5,14 @@
 /* program that reads text from standard-input, 
    and prints the total number of distinct words found in the text. 
 */
-DICT_SET_DEF2(dict_str, string_t, STRING_OPLIST)
+DICT_SET_DEF(dict_str, string_t, STRING_OPLIST)
 
 int main(void)
 {
   M_LET(word, STRING_OPLIST)
     M_LET(wordcount, DICT_SET_OPLIST(dict_str, STRING_OPLIST)) {
     while (string_fget_word(word, " \t\n,.!;:?", stdin))
-      dict_str_set_at(wordcount, word);
-    printf ("Words: %lu\n", dict_str_size(wordcount));
+      dict_str_push(wordcount, word);
+    printf ("Words: %zu\n", dict_str_size(wordcount));
   }
 }

example/ex-grep01.c

@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include "m-string.h"
+#include "m-array.h"
+#include "m-dict.h"
+
+ARRAY_DEF(array_size, size_t)
+#define M_OPL_array_size_t() ARRAY_OPLIST(array_size)
+DICT_DEF2(map_pos, string_t, array_size_t)
+#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) {
+     M_LET(word, string_t)
+     M_LET(positions, map_pos_t) {
+        FILE *f = fopen(argv[1], "rt");
+        if (!f) return 1;
+        while (string_fget_word(word, " \t\n\r\"(),=", f)) {
+          array_size_t *array = map_pos_get_at(positions, word);
+          array_size_push_back(*array, (size_t)ftell(f) - string_size(word));
+        }
+        fclose(f);
+
+        for M_EACH(pair, positions, map_pos_t) {
+         string_fputs(stdout, pair->key);
+         for M_EACH(pos, pair->value, array_size_t)
+            printf(" %zu", *pos);
+         printf("\n");
+        }
+     }
+   }
+}

example/ex-json01.c

@@ -0,0 +1,64 @@
+#include "m-serial-json.h"
+#include "m-tuple.h"
+#include "m-array.h"
+
+// Serial json is not supported for standard types if not C11
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L  
+
+// Let's define a 'person' composed of several fields.
+TUPLE_DEF2(person,
+           (surname, string_t),
+           (age, int),
+           (present, bool)
+           )
+#define M_OPL_person_t() TUPLE_OPLIST(person, M_DEFAULT_OPLIST, STRING_OPLIST, M_DEFAULT_OPLIST )
+
+// Let's define an array of person
+ARRAY_DEF(base, person_t)
+#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)
+{
+  M_LET(base, base_t) {
+    read(base, "ex-json01.json");
+    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);    
+}
+
+#else
+int main(void)
+{
+  exit(0);    
+}
+#endif

example/ex-json01.json

@@ -0,0 +1,7 @@
+[
+    { "surname": "Angel", "age": 1, "present": false},
+    { "surname": "Snake", "age": 2, "present": true},
+    { "surname": "BallOfBase", "age": 5, "present": true}
+]
+
+    

example/ex-mph.c

@@ -0,0 +1,246 @@
+#include <stdio.h>
+#include <stdint.h>
+
+#include "m-array.h"
+#include "m-dict.h"
+#include "m-string.h"
+#include "m-algo.h"
+
+/* Based on:
+ *  Easy Perfect Minimal Hashing 
+ *  By Steve Hanov. Released to the public domain.
+ *  http://stevehanov.ca/blog/index.php?id=119
+ *
+ * Based on:
+ * Edward A. Fox, Lenwood S. Heath, Qi Fan Chen and Amjad M. Daoud, 
+ * "Practical minimal perfect hash functions for large databases", CACM, 35(1):105-121
+ *
+ * also a good reference:
+ *  Compress, Hash, and Displace algorithm by Djamal Belazzougui,
+ * Fabiano C. Botelho, and Martin Dietzfelbinger
+ */
+
+
+
+/* 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)
+
+// Defin an array of integer
+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
+ARRAY_DEF(array_seed, int32_t)
+#define M_OPL_array_seed_t() ARRAY_OPLIST(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)
+static inline int array_cstr_cmp(const array_cstr_t a, const array_cstr_t b) {
+  size_t sa = array_cstr_size(a);
+  size_t sb = array_cstr_size(b);
+  return (sa > sb) ? -1 : (sa < sb);
+}
+#define M_OPL_array_cstr_t() M_OPEXTEND(ARRAY_OPLIST(array_cstr, M_CSTR_OPLIST), CMP(array_cstr_cmp))
+
+// Define an array of array of constant string, and some algo over this container
+ARRAY_DEF(array_bucket, array_cstr_t)
+#define M_OPL_array_bucket_t() ARRAY_OPLIST(array_bucket, M_OPL_array_cstr_t() )
+ALGO_DEF(array_bucket, array_bucket_t)
+
+// Define an array of string to save the input.
+ARRAY_DEF(array_string, string_t)
+#define M_OPL_array_string_t() ARRAY_OPLIST(array_string, M_OPL_string_t())
+
+
+
+
+/* The algorithm may not converge on all inputs if the hash function
+ * doesn't randomly distribute the inputs:
+ * str1 != str2 ==> \exist seed \such_as hash(seed,str1) != hash(seed, str2)
+ * The first hash function below doesn't provide the needed property for
+ * inputs with two words 'a' and 'c'
+ * The second one is more robust but may still have this issue.
+ */
+static uint32_t hash(int32_t seed, const char str[])
+{
+#if 0
+  if (seed == 0) seed = 0x01000193;
+  while (*str) {
+    seed = ((seed * 0x01000193) ^ *str);
+    str++;
+  }
+  return seed;
+#else
+  if (seed == 0) seed = 0x811C9DC5;
+  while (*str) {
+    seed = (seed ^ *str) * 16777619;
+    str++;
+  }
+  return seed ^ (seed >> 16);
+#endif
+}
+
+// Step 1: place all key keys into buckets
+static void
+CreateMinimalPerfectHash1(array_seed_t seed, array_value_t value,
+                          array_bucket_t bucket,
+                          const dict_mph_t dict)
+{
+  size_t size = dict_mph_size (dict);
+  
+  array_value_resize(value, size);
+  array_seed_resize(seed, size);
+  array_bucket_resize(bucket, size);
+
+  for M_EACH(item, dict, dict_mph_t) {
+      size_t i = hash(0, item->key) % size;
+      array_cstr_push_back (*array_bucket_get (bucket, i), item->key);
+    }
+}
+
+// Step 2:   Sort the buckets and process the ones with the most items first.
+static void
+CreateMinimalPerfectHash2(array_seed_t seed, array_value_t value,
+                          array_bucket_t bucket,
+                          const dict_mph_t dict)
+{
+  size_t size = dict_mph_size (dict);
+  array_bucket_sort(bucket);
+  M_LET(slots, array_seed_t) {
+    for M_EACH(b, bucket, array_bucket_t) {
+        if (array_cstr_size(*b) <= 1)
+          break;
+        size_t d = 1;
+        /* Repeatedly try different values of d until we find a hash function
+           that places all items in the bucket into free slots.
+           This may loop forever on some inputs if the hash function is not good
+           enought. */
+        for(bool cont = true; cont ; ) {
+          cont = false;
+          array_seed_clean(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)){
+                d++;
+                cont = true;
+                break;
+              }
+              array_seed_push_back (slots, s);
+            }
+        }
+        // Fill in the seed & value with the computed value
+        array_seed_set_at(seed, hash(0, *array_cstr_get(*b, 0)) % size, d);
+        d = 0;
+        for M_EACH(it, *b, array_cstr_t) {
+            array_value_set_at(value,
+                               *array_seed_get(slots, d),
+                               *dict_mph_get(dict, *it));
+            d++;
+          }
+      }
+  }
+}
+
+/* Step 3: 
+ * Only buckets with 1 item remain. Process them more quickly by directly
+ * placing them into a free slot. Use a negative value of d to indicate
+ * this.
+ */
+static void
+CreateMinimalPerfectHash3(array_seed_t seed, array_value_t value,
+                          array_bucket_t bucket,
+                          const dict_mph_t dict)
+{
+  size_t size = dict_mph_size (dict);
+
+  M_LET(freelist, array_seed_t) {
+    // Get a list of available slot
+    for(size_t i = 0; i < size; i++)
+      if (*array_value_get(value, i) == 0)
+        array_seed_push_back(freelist, i);
+    for M_EACH(b, bucket, array_bucket_t) {
+        if (array_cstr_size(*b) != 1)
+          continue;
+        int32_t slot;
+        array_seed_pop_back(&slot, freelist);
+        /*We subtract one to ensure it's negative even if the zeroeth slot was
+          used. */
+        array_seed_set_at (seed, hash(0, *array_cstr_get(*b, 0)) % size,
+                           -slot-1);
+        array_value_set_at(value, slot, *dict_mph_get(dict, *array_cstr_get(*b, 0)));
+      }
+  }
+}
+
+static void
+CreateMinimalPerfectHash(array_seed_t seed, array_value_t value,
+                         const dict_mph_t dict)
+{
+  M_LET(bucket, array_bucket_t) {
+    CreateMinimalPerfectHash1(seed, value, bucket, dict);
+    CreateMinimalPerfectHash2(seed, value, bucket, dict);
+    CreateMinimalPerfectHash3(seed, value, bucket, dict);
+  }
+}
+
+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();
+  uint32_t line = 1;
+  M_LET(str, string_t) {
+    while (!feof(f) && !ferror(f)) {
+      string_fgets(str, f, STRING_READ_PURE_LINE);
+      string_strim(str);
+      if (!string_empty_p(str)) {
+        // Not clean as items of 'dict' points are linked to items of 'arr'
+        // and the containers are not aware of this link.
+        array_string_push_back (arr, str);
+        dict_mph_set_at(dict, string_get_cstr(*array_string_back(arr)), line);
+        line++;
+      }
+    }
+  }
+  fclose(f);
+}
+
+static uint32_t
+perfect_hash_lockup(array_seed_t seed, array_value_t value,
+                    const char key[])
+{
+  int32_t s = *array_seed_get(seed, hash(0, key) % array_seed_size(seed));
+  if (s < 0)
+    return *array_value_get(value, -s-1);
+  else
+    return *array_value_get(value, hash(s, key) % array_value_size(value));
+}
+
+static void
+test(array_seed_t seed, array_value_t value, dict_mph_t dict)
+{
+  for M_EACH(item, dict, dict_mph_t) {
+      const char *key = item->key;
+      uint32_t v = perfect_hash_lockup(seed, value, key);
+      if (v != item->value) {
+        fprintf(stderr, "ERROR for %s: %u VS %u\n", key, v, item->value);
+      }
+    }
+}
+
+int main(int argc, const char *argv[])
+{
+  M_LET(arr, array_string_t) M_LET(dict, dict_mph_t) M_LET(seed, array_seed_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);
+    CreateMinimalPerfectHash(seed, value, dict);
+    test(seed, value, dict);
+  }
+  
+  return 0;
+}

example/ex-multi01.c

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

example/ex-multi02.c

@@ -1,3 +1,5 @@
+#if HAVE_GMP
+
 #include <stdio.h>
 #include <gmp.h>
 
@@ -50,14 +52,19 @@ int main(void)
               // 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));
+                        *my_integer_cget_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));
+                mpz_out_str(stdout, 10, *my_integer_cget_z(p->value));
                 printf("\n");
               }
             }
         }
     } /* All variables are automatically cleared beyond this point */
 }
+
+#else
+// Nothing to do
+int main(void) { return 0; }
+#endif

example/ex-multi03.c

@@ -12,7 +12,9 @@ unsigned long long rand_seed;
 #include "m-variant.h"
 
 /* This example will show how to create JSON-like files.
-   This is a JSON **like** syntax, not exactly JSON format */
+   This is a JSON **like** syntax, not exactly JSON format.
+   For an example with JSON format, see https://github.com/P-p-H-d/mjsonlib
+*/
 
 /* First let's handle the OUT/IN functions of boolean */
 static inline void boolean_out_str(FILE *f, bool b)

example/ex-multi04.c

@@ -0,0 +1,90 @@
+#include <stdio.h>
+
+#include "m-tuple.h"
+#include "m-array.h"
+#include "m-string.h"
+#include "m-list.h"
+#include "m-buffer.h"
+
+/* This example chains the structure in different ways in
+   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)
+
+ARRAY_DEF(symbol_list, symbol_t)
+#define M_OPL_symbol_list_t() ARRAY_OPLIST(symbol_list, M_OPL_symbol_t())
+
+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)
+
+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)
+
+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() )
+
+TUPLE_DEF2(my_triple_tuple, (name, string_t), (inner_tuple, my_tuple_t), (list, list_of_tuple_of_tuple_t) )
+#define M_OPL_my_triple_tuple_t() TUPLE_OPLIST(my_triple_tuple, STRING_OPLIST, M_OPL_my_tuple_t(), M_OPL_list_of_tuple_of_tuple_t())
+
+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())
+           
+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_DEF2(mlib_points, (first_ref, mlib_point_ptr, M_PTR_OPLIST),
+           (second_ref, mlib_point_ptr, M_PTR_OPLIST),
+           (third, mlib_point_t))
+#define M_OPL_mlib_points_t()                                           \
+  TUPLE_OPLIST(mlib_points, M_PTR_OPLIST, M_PTR_OPLIST, M_OPL_mlib_point_t())
+
+static void let2(void)
+{
+  M_LET((p1, 4, 4), (p2, 5, 5), mlib_point_t) {
+    M_LET(pair, mlib_points_t) {
+      pair->first_ref = p1;
+      pair->second_ref = p2;
+      pair->third->x = pair->third->y = 6;
+      
+      assert(pair->first_ref->x == 4);
+      p1->x = 10;
+      assert(pair->first_ref->x == 10);
+      
+      assert(pair->third->x == 6);
+    }
+  }
+}
+
+static void let(void)
+{
+  M_LET(s, symbol_t)
+    M_LET(l, symbol_list_t)
+    M_LET(r,record_t)
+    M_LET(tup, my_tuple_t)
+    M_LET(l2, my_list_of_tuple_t)
+    M_LET(tuptup, my_tuple_of_tuple_t)
+    M_LET(ltuptup, list_of_tuple_of_tuple_t)
+    M_LET(tuptuptup, my_triple_tuple_t)
+    M_LET(junc, my_junction_t)
+    {
+      printf("Init ok\n");
+    }
+}
+
+int main(void)
+{
+  let();
+  let2();
+}
+

example/ex-multi05.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+
+#include "m-array.h"
+#include "m-string.h"
+
+// Let's create an array of string_t and register it globaly
+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;
+}

example/ex-rbtree01.c

@@ -4,6 +4,15 @@
 
 #include "m-rbtree.h"
 
+// Let's define one utility function.
+void *xmalloc(size_t n);
+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 +21,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 +33,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)
 {

example/ex-section.c

@@ -0,0 +1,40 @@
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+
+#include <stdio.h>
+
+#include "m-array.h"
+#include "m-tuple.h"
+#include "m-dict.h"
+#include "m-string.h"
+
+TUPLE_DEF2(symbol, (offset, long), (value, long))
+#define M_OPL_symbol_t() TUPLE_OPLIST(symbol, M_DEFAULT_OPLIST, M_DEFAULT_OPLIST)
+
+ARRAY_DEF(array_symbol, symbol_t)
+#define M_OPL_array_symbol_t() ARRAY_OPLIST(array_symbol, M_OPL_symbol_t())
+
+DICT_DEF2(sections, string_t, array_symbol_t)
+#define M_OPL_sections_t() DICT_OPLIST(sections, STRING_OPLIST, M_OPL_array_symbol_t())
+
+int main(int argc, const char *argv[])
+{
+  if (argc < 2) abort();
+  FILE *f = fopen(argv[1], "rt");
+  if (!f) abort();
+  M_LET(sc, sections_t) {
+    sections_in_str(sc, f);
+    array_symbol_t *a = sections_get(sc, STRING_CTE(".text"));
+    if (a == NULL) {
+      printf("There is no .text section.");
+    } else {
+      printf("Section .text is :");
+      array_symbol_out_str(stdout, *a);
+      printf("\n");
+    }
+  }
+  return 0;
+}
+
+#else
+int main(void) { return 0; }
+#endif

example/ex11-algo01.c

@@ -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;
+}

example/ex11-algo02.c

@@ -0,0 +1,77 @@
+#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 */
+TUPLE_DEF2(employee,
+           (name, string_t),
+           (age, int),
+           (idnum, int))
+#define M_OPL_employee_t() TUPLE_OPLIST(employee, STRING_OPLIST, M_DEFAULT_OPLIST, M_DEFAULT_OPLIST)
+
+/* Define an array of employee and some 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 */
+FUNC_OBJ_INS_DEF(compare_by,
+                 vector_employee_cmp_obj,
+                 (a, b), { 
+                   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;
+                 },
+                 (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) {
+    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)
+    ret = vector_employee_in_serial(base, in);
+  // Let's handle errors
+  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);
+  }
+  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));
+    printf("Employees sorted by idnum are: ");
+    vector_employee_out_str(stdout, emps);
+
+    M_LET( (cmp, STRING_CTE("name")), compare_by_t )
+      vector_employee_sort_fo(emps, compare_by_as_interface(cmp));
+    printf("\nEmployees sorted by name are: ");
+    vector_employee_out_str(stdout, emps);
+    printf("\n");
+  }
+  return 0;
+}

example/ex11-algo02.json

@@ -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}    
+]
+

m-array.h

@@ -1,7 +1,7 @@
 /*
  * M*LIB - dynamic ARRAY module
  *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2020, 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:
@@ -22,33 +22,52 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#ifndef __M_ARRAY_H
-#define __M_ARRAY_H
+#ifndef MSTARLIB_ARRAY_H
+#define MSTARLIB_ARRAY_H
 
 #include "m-core.h"
 
-/* Define an array of a given type.
+/* Define a dynamic array of the given type and its associated functions.
    USAGE: ARRAY_DEF(name, type [, oplist_of_the_type]) */
 #define ARRAY_DEF(name, ...)                                            \
-  ARRAYI_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                                \
-  ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__), M_C(name,_t), M_C(name,_it_t) ), \
-   (name, __VA_ARGS__,                                      M_C(name,_t), M_C(name,_it_t))))
+  ARRAYI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
+             ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name,_t), M_C(name,_it_t) ), \
+              (name, __VA_ARGS__,                                      M_C(name,_t), M_C(name,_it_t))))
 
-/* Define the oplist of an array of type.
+
+/* Define the oplist of a dynamic array given its name and its oplist.
+   If no oplist is given it is assumed to be M_DEFAULT_OPLIST
    USAGE: ARRAY_OPLIST(name[, oplist of the type]) */
 #define ARRAY_OPLIST(...)                                               \
-  ARRAYI_OPLIST(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
-                ((__VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__) ),   \
-                 (__VA_ARGS__ )))
+  ARRAYI_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                          \
+                   ((__VA_ARGS__, M_DEFAULT_OPLIST),			\
+                    (__VA_ARGS__ )))
 
 
+
+/********************************************************************************/
 /********************************** INTERNAL ************************************/
+/********************************************************************************/
 
-#define ARRAYI_OPLIST(arg) ARRAYI_OPLIST2 arg
+/* Deferred evaluation for the oplist definition,
+   so that all arguments are evaluated before further expansion */
+#define ARRAYI_OPLIST_P1(arg) ARRAYI_OPLIST_P2 arg
 
-#define ARRAYI_OPLIST2(name, oplist)					\
-  (INIT(M_C(name, _init))						\
+/* Validation of the given oplist */
+#define ARRAYI_OPLIST_P2(name, oplist)					\
+  M_IF_OPLIST(oplist)(ARRAYI_OPLIST_P3, ARRAYI_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define ARRAYI_OPLIST_FAILURE(name, oplist)		\
+  M_LIB_ERROR(ARGUMENT_OF_ARRAY_OPLIST_IS_NOT_AN_OPLIST, name, oplist)
+
+/* OPLIST definition of a dynamic array */
+/* FIXME: Do we want to export some methods as they are slow and 
+   are not fit to be used for building other methods (like _it_remove)? */
+#define ARRAYI_OPLIST_P3(name, oplist)					\
+  (INIT(M_C(name, _init))                                               \
    ,INIT_SET(M_C(name, _init_set))					\
+   ,INIT_WITH(API_1(M_INIT_VAI))                                        \
    ,SET(M_C(name, _set))						\
    ,CLEAR(M_C(name, _clear))						\
    ,INIT_MOVE(M_C(name, _init_move))					\
@@ -56,6 +75,7 @@
    ,SWAP(M_C(name, _swap))						\
    ,TYPE(M_C(name,_t))							\
    ,SUBTYPE(M_C(name, _type_t))						\
+   ,TEST_EMPTY(M_C(name,_empty_p))                                      \
    ,IT_TYPE(M_C(name,_it_t))						\
    ,IT_FIRST(M_C(name,_it))						\
    ,IT_LAST(M_C(name,_it_last))						\
@@ -68,15 +88,30 @@
    ,IT_PREVIOUS(M_C(name,_previous))					\
    ,IT_REF(M_C(name,_ref))						\
    ,IT_CREF(M_C(name,_cref))						\
-   ,IT_REMOVE(M_C(name,_remove))					\
+   ,IT_INSERT(M_C(name,_insert))                                        \
+   ,IT_REMOVE(M_C(name,_remove))                                        \
    ,CLEAN(M_C(name,_clean))						\
+   ,KEY_TYPE(size_t)                                                    \
+   ,VALUE_TYPE(M_C(name, _type_t))                                      \
+   ,KEY_OPLIST(M_DEFAULT_OPLIST)                                        \
+   ,VALUE_OPLIST(oplist)                                                \
+   ,SET_KEY(M_C(name, _set_at))                                         \
+   ,GET_KEY(M_C(name, _get))                                            \
+   ,M_IF_METHOD(INIT, oplist)(GET_SET_KEY(M_C(name, _get_at)) ,)        \
+   ,ERASE_KEY(M_C(name, _erase))                                        \
+   ,GET_SIZE(M_C(name, _size))                                          \
    ,PUSH(M_C(name,_push_back))						\
    ,POP(M_C(name,_pop_back))						\
+   ,PUSH_MOVE(M_C(name,_push_move))                                     \
+   ,POP_MOVE(M_C(name,_pop_move))                                       \
    ,OPLIST(oplist)                                                      \
    ,M_IF_METHOD(CMP, oplist)(SORT(M_C(name, _special_sort)),)		\
    ,M_IF_METHOD(GET_STR, oplist)(GET_STR(M_C(name, _get_str)),)		\
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(M_C(name, _parse_str)),)   \
    ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_C(name, _out_str)),)		\
    ,M_IF_METHOD(IN_STR, oplist)(IN_STR(M_C(name, _in_str)),)		\
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(M_C(name, _out_serial)),) \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(M_C(name, _in_serial)),)   \
    ,M_IF_METHOD(EQUAL, oplist)(EQUAL(M_C(name, _equal_p)),)		\
    ,M_IF_METHOD(HASH, oplist)(HASH(M_C(name, _hash)),)			\
    ,M_IF_METHOD(NEW, oplist)(NEW(M_GET_NEW oplist),)                    \
@@ -84,36 +119,59 @@
    ,M_IF_METHOD(DEL, oplist)(DEL(M_GET_DEL oplist),)                    \
    )
 
+/* Define the internal contract of an array */
 #define ARRAYI_CONTRACT(a) do {                 \
     assert (a != NULL);                         \
     assert (a->size <= a->alloc);               \
     assert (a->size == 0 || a->ptr != NULL);    \
   } while (0)
 
-// Deferred evaluation.
-#define ARRAYI_DEF(arg) ARRAYI_DEF2 arg
+/* Deferred evaluation for the array definition,
+   so that all arguments are evaluated before further expansion */
+#define ARRAYI_DEF_P1(arg) ARRAYI_DEF_P2 arg
 
-// Internal definition.
-#define ARRAYI_DEF2(name, type, oplist, array_t, array_it_t)            \
+/* Validate the oplist before going further */
+#define ARRAYI_DEF_P2(name, type, oplist, array_t, it_t)                \
+  M_IF_OPLIST(oplist)(ARRAYI_DEF_P3, ARRAYI_DEF_FAILURE)(name, type, oplist, array_t, it_t)
+
+/* Stop processing with a compilation failure */
+#define ARRAYI_DEF_FAILURE(name, type, oplist, array_t, it_t)   \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(ARRAY_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* Internal definition:
+   - name: prefix to be used
+   - type: type of the elements of the array
+   - oplist: oplist of the type of the elements of the array
+   - array_t: alias for M_C(name, _t) [ type of the array ]
+   - it_t: alias for M_C(name, _it_t) [ iterator of the array ]
+*/
+#define ARRAYI_DEF_P3(name, type, oplist, array_t, it_t)                \
 									\
   typedef struct M_C(name, _s) {					\
-    size_t size, alloc;                                                 \
-    type *ptr;                                                          \
+    size_t size;            /* Number of elements in the array */       \
+    size_t alloc;           /* Allocated size for the array base */     \
+    type *ptr;              /* Pointer to the array base */             \
   } array_t[1];                                                         \
+  typedef struct M_C(name, _s) *M_C(name, _ptr);                        \
+  typedef const struct M_C(name, _s) *M_C(name, _srcptr);               \
 									\
   typedef type M_C(name, _type_t);					\
 									\
   typedef struct M_C(name, _it_s) {					\
-    size_t index;                                                       \
-    const struct M_C(name, _s) *array;					\
-  } array_it_t[1];                                                      \
+    size_t index;                       /* Index of the element */      \
+    const struct M_C(name, _s) *array;	/* Reference of the array */    \
+  } it_t[1];                                                            \
   									\
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                      \
+                                                                        \
   static inline void                                                    \
   M_C(name, _init)(array_t v)						\
   {                                                                     \
     assert (v != NULL);                                                 \
-    v->size = v->alloc = 0;                                             \
-    v->ptr = NULL;                                                      \
+    /* Initialy, the array is empty with nothing allocated */           \
+    v->size  = 0;                                                       \
+    v->alloc = 0;                                                       \
+    v->ptr   = NULL;                                                    \
     ARRAYI_CONTRACT(v);                                                 \
   }                                                                     \
   									\
@@ -122,7 +180,7 @@
   {                                                                     \
     ARRAYI_CONTRACT(v);                                                 \
     for(size_t i = 0; i < v->size; i++)                                 \
-      M_GET_CLEAR oplist(v->ptr[i]);                                    \
+      M_CALL_CLEAR(oplist, v->ptr[i]);                                  \
     v->size = 0;                                                        \
     ARRAYI_CONTRACT(v);                                                 \
   }                                                                     \
@@ -132,7 +190,7 @@
   {                                                                     \
     ARRAYI_CONTRACT(v);                                                 \
     M_C(name, _clean)(v);						\
-    M_GET_FREE oplist(v->ptr);                                          \
+    M_CALL_FREE(oplist, v->ptr);                                        \
     v->alloc = 0;                                                       \
     v->ptr = NULL;                                                      \
   }                                                                     \
@@ -145,7 +203,7 @@
     if (M_UNLIKELY (d == s)) return;                                    \
     if (s->size > d->alloc) {                                           \
       const size_t alloc = s->size;					\
-      type *ptr = M_GET_REALLOC oplist (type, d->ptr, alloc);           \
+      type *ptr = M_CALL_REALLOC(oplist, type, d->ptr, alloc);          \
       if (M_UNLIKELY (ptr == NULL)) {					\
         M_MEMORY_FULL(sizeof (type) * alloc);                           \
         return ;                                                        \
@@ -155,11 +213,11 @@
     }                                                                   \
     size_t i, step1 = M_MIN(s->size, d->size);                          \
     for(i = 0; i < step1; i++)                                          \
-      M_GET_SET oplist (d->ptr[i], s->ptr[i]);                          \
+      M_CALL_SET(oplist, d->ptr[i], s->ptr[i]);                         \
     for( ; i < s->size; i++)                                            \
-      M_GET_INIT_SET oplist (d->ptr[i], s->ptr[i]);                     \
+      M_CALL_INIT_SET(oplist, d->ptr[i], s->ptr[i]);                    \
     for( ; i < d->size; i++)                                            \
-      M_GET_CLEAR oplist (d->ptr[i]);                                   \
+      M_CALL_CLEAR(oplist, d->ptr[i]);                                  \
     d->size = s->size;                                                  \
     ARRAYI_CONTRACT(d);                                                 \
   }                                                                     \
@@ -180,7 +238,7 @@
     d->size  = s->size;                                                 \
     d->alloc = s->alloc;                                                \
     d->ptr   = s->ptr;                                                  \
-    s->size  = s->alloc = 0;                                            \
+    s->alloc = 0;                                                       \
     s->ptr   = NULL;                                                    \
     ARRAYI_CONTRACT(d);                                                 \
   }                                                                     \
@@ -194,14 +252,14 @@
   }                                                                     \
   									\
   static inline void                                                    \
-  M_C(name, _set_at)(array_t v, size_t i, type x)			\
+  M_C(name, _set_at)(array_t v, size_t i, type const x)			\
   {                                                                     \
     ARRAYI_CONTRACT(v);                                                 \
     assert(v->size > 0 && v->ptr != NULL && i < v->size);               \
-    M_GET_SET oplist(v->ptr[i], x);                                     \
+    M_CALL_SET(oplist, v->ptr[i], x);                                   \
   }                                                                     \
                                                                         \
-  static inline const type *                                            \
+  static inline type const *                                            \
   M_C(name, _back)(array_t v)						\
   {                                                                     \
     ARRAYI_CONTRACT(v);                                                 \
@@ -215,13 +273,13 @@
     ARRAYI_CONTRACT(v);                                                 \
     if (M_UNLIKELY (v->size >= v->alloc)) {                             \
       assert(v->size == v->alloc);                                      \
-      size_t alloc = M_GET_INC_ALLOC oplist (v->alloc);                 \
+      size_t alloc = M_CALL_INC_ALLOC(oplist, v->alloc);                \
       if (M_UNLIKELY (alloc <= v->alloc)) {				\
         M_MEMORY_FULL(sizeof (type) * alloc);                           \
         return NULL;							\
       }                                                                 \
       assert (alloc > v->size);                                         \
-      type *ptr = M_GET_REALLOC oplist (type, v->ptr, alloc);           \
+      type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, alloc);          \
       if (M_UNLIKELY (ptr == NULL) ) {                                  \
         M_MEMORY_FULL(sizeof (type) * alloc);                           \
         return NULL;                                                    \
@@ -233,6 +291,7 @@
     type *ret = &v->ptr[v->size];                                       \
     v->size++;                                                          \
     ARRAYI_CONTRACT(v);                                                 \
+    M_ASSUME(ret != NULL);						\
     return ret;                                                         \
   }                                                                     \
                                                                         \
@@ -240,19 +299,31 @@
   M_C(name, _push_back)(array_t v, type const x)			\
   {                                                                     \
     type *data = M_C(name, _push_raw)(v);				\
-    if (M_UNLIKELY (data == NULL) )                                     \
-      return;                                                           \
-    M_GET_INIT_SET oplist(*data, x);                                    \
+    if (M_UNLIKELY (data == NULL) )					\
+      return;								\
+    M_CALL_INIT_SET(oplist, *data, x);                                  \
   }                                                                     \
   									\
+  M_IF_METHOD(INIT, oplist)(                                            \
   static inline type *                                                  \
   M_C(name, _push_new)(array_t v)					\
   {                                                                     \
     type *data = M_C(name, _push_raw)(v);				\
     if (M_UNLIKELY (data == NULL) )                                     \
       return NULL;                                                      \
-    M_GET_INIT oplist(*data);                                           \
+    M_CALL_INIT(oplist, *data);                                         \
     return data;                                                        \
+  }                                                                     \
+  , /* No INIT */ )                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _push_move)(array_t v, type *x)			        \
+  {                                                                     \
+    assert (x != NULL);                                                 \
+    type *data = M_C(name, _push_raw)(v);				\
+    if (M_UNLIKELY (data == NULL) )                                     \
+      return;                                                           \
+    M_DO_INIT_MOVE (oplist, *data, *x);                                 \
   }                                                                     \
   									\
   static inline void                                                    \
@@ -262,13 +333,13 @@
     assert (key <= v->size);                                            \
     if (M_UNLIKELY (v->size >= v->alloc) ) {                            \
       assert(v->size == v->alloc);                                      \
-      size_t alloc = M_GET_INC_ALLOC oplist (v->alloc);                 \
+      size_t alloc = M_CALL_INC_ALLOC(oplist, v->alloc);                \
       if (M_UNLIKELY (alloc <= v->alloc)) {				\
         M_MEMORY_FULL(sizeof (type) * alloc);                           \
         return ;                                                        \
       }                                                                 \
       assert (alloc > v->size);                                         \
-      type *ptr = M_GET_REALLOC oplist (type, v->ptr, alloc);           \
+      type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, alloc);          \
       if (M_UNLIKELY (ptr == NULL) ) {                                  \
         M_MEMORY_FULL(sizeof (type) * alloc);                           \
         return;                                                         \
@@ -279,10 +350,11 @@
     assert(v->ptr != NULL);                                             \
     memmove(&v->ptr[key+1], &v->ptr[key], (v->size-key)*sizeof(type));  \
     v->size++;                                                          \
-    M_GET_INIT_SET oplist (v->ptr[key], x);                             \
+    M_CALL_INIT_SET(oplist, v->ptr[key], x);                            \
     ARRAYI_CONTRACT(v);                                                 \
   }                                                                     \
                                                                         \
+  M_IF_METHOD(INIT, oplist)(                                            \
   static inline void                                                    \
   M_C(name, _resize)(array_t v, size_t size)				\
   {                                                                     \
@@ -290,13 +362,13 @@
     if (v->size > size) {                                               \
       /* Decrease size of array */                                      \
       for(size_t i = size ; i < v->size; i++)                           \
-        M_GET_CLEAR oplist(v->ptr[i]);                                  \
+        M_CALL_CLEAR(oplist, v->ptr[i]);                                \
       v->size = size;                                                   \
     } else if (v->size < size) {                                        \
       /* Increase size of array */                                      \
       if (size > v->alloc) {                                            \
         size_t alloc = size ;                                           \
-        type *ptr = M_GET_REALLOC oplist (type, v->ptr, alloc);         \
+        type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, alloc);        \
         if (M_UNLIKELY (ptr == NULL) ) {                                \
           M_MEMORY_FULL(sizeof (type) * alloc);                         \
           return;                                                       \
@@ -305,11 +377,12 @@
         v->alloc = alloc;                                               \
       }                                                                 \
       for(size_t i = v->size ; i < size; i++)                           \
-        M_GET_INIT oplist(v->ptr[i]);                                   \
+        M_CALL_INIT(oplist, v->ptr[i]);                                 \
       v->size = size;                                                   \
     }                                                                   \
     ARRAYI_CONTRACT(v);                                                 \
   }                                                                     \
+  , /* No INIT */ )                                                     \
                                                                         \
   static inline void                                                    \
   M_C(name, _reserve)(array_t v, size_t alloc)				\
@@ -320,11 +393,11 @@
       alloc = v->size;                                                  \
     }                                                                   \
     if (M_UNLIKELY (alloc == 0)) {                                      \
-      M_GET_FREE oplist (v->ptr);                                       \
+      M_CALL_FREE(oplist, v->ptr);                                      \
       v->size = v->alloc = 0;                                           \
       v->ptr = NULL;                                                    \
     } else {                                                            \
-      type *ptr = M_GET_REALLOC oplist (type, v->ptr, alloc);           \
+      type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, alloc);          \
       if (M_UNLIKELY (ptr == NULL) ) {                                  \
         M_MEMORY_FULL(sizeof (type) * alloc);                           \
         return;                                                         \
@@ -335,57 +408,75 @@
     ARRAYI_CONTRACT(v);                                                 \
   }                                                                     \
                                                                         \
-  static inline void                                                    \
-  M_C(name, _set_at2)(array_t v, size_t idx, type x)			\
+  M_IF_METHOD(INIT, oplist)(                                            \
+  static inline type *                                                  \
+  M_C(name, _get_at)(array_t v, size_t idx)                             \
   {                                                                     \
     ARRAYI_CONTRACT(v);                                                 \
     const size_t size = idx + 1;                                        \
-    /* NOTE: set at and resize if needed */                             \
+    /* resize if needed */                                              \
     if (v->size <= size) {                                              \
       /* Increase size of array */                                      \
       if (M_UNLIKELY (size > v->alloc) ) {                              \
-        size_t alloc = M_GET_INC_ALLOC oplist (size) ;                  \
+        size_t alloc = M_CALL_INC_ALLOC(oplist, size) ;                 \
+        /* In case of overflow of size_t */                             \
 	if (M_UNLIKELY (alloc <= v->alloc)) {				\
 	  M_MEMORY_FULL(sizeof (type) * alloc);				\
-	  return ;							\
+	  return NULL;							\
 	}								\
-        type *ptr = M_GET_REALLOC oplist (type, v->ptr, alloc);         \
+        type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, alloc);        \
         if (M_UNLIKELY (ptr == NULL) ) {                                \
           M_MEMORY_FULL(sizeof (type) * alloc);                         \
-          return;                                                       \
+          return NULL;                                                  \
         }                                                               \
         v->ptr = ptr;                                                   \
         v->alloc = alloc;                                               \
       }                                                                 \
       for(size_t i = v->size ; i < size; i++)                           \
-        M_GET_INIT oplist(v->ptr[i]);                                   \
+        M_CALL_INIT(oplist, v->ptr[i]);                                 \
       v->size = size;                                                   \
     }                                                                   \
     assert (idx < v->size);                                             \
-    M_GET_SET oplist(v->ptr[idx], x);                                   \
     ARRAYI_CONTRACT(v);                                                 \
+    return &v->ptr[idx];                                                \
   }                                                                     \
+  , /* No INIT */)                                                      \
                                                                         \
   static inline void                                                    \
   M_C(name, _pop_back)(type *dest, array_t v)				\
   {                                                                     \
     ARRAYI_CONTRACT(v);                                                 \
+    assert (v->size > 0 && v->ptr != NULL);                             \
     v->size--;                                                          \
-    if (dest)                                                           \
+    if (dest) {                                                         \
       M_DO_MOVE (oplist, *dest, v->ptr[v->size]);                       \
-    else                                                                \
-      M_GET_CLEAR oplist (v->ptr[v->size]);                             \
+    } else {                                                            \
+      M_CALL_CLEAR(oplist, v->ptr[v->size]);                            \
+    }                                                                   \
     ARRAYI_CONTRACT(v);                                                 \
   }                                                                     \
                                                                         \
   static inline void                                                    \
-  M_C(name, _pop_until)(array_t v, array_it_t pos)                      \
+  M_C(name, _pop_move)(type *dest, array_t v)				\
+  {                                                                     \
+    ARRAYI_CONTRACT(v);                                                 \
+    assert (v->size > 0 && v->ptr != NULL);                             \
+    assert (dest != NULL);                                              \
+    v->size--;                                                          \
+    M_DO_INIT_MOVE (oplist, *dest, v->ptr[v->size]);                    \
+    ARRAYI_CONTRACT(v);                                                 \
+  }                                                                     \
+                                                                        \
+  M_IF_METHOD(INIT, oplist)(                                            \
+  static inline void                                                    \
+  M_C(name, _pop_until)(array_t v, it_t pos)                            \
   {                                                                     \
     ARRAYI_CONTRACT(v);                                                 \
     assert (v == pos->array);                                           \
     M_ASSUME (pos->index <= v->size);                                   \
     M_C(name, _resize)(v, pos->index);                                  \
   }                                                                     \
+  , /* No INIT */ )                                                     \
                                                                         \
   static inline bool                                                    \
   M_C(name, _empty_p)(const array_t v)					\
@@ -413,28 +504,47 @@
   {                                                                     \
     ARRAYI_CONTRACT(v);                                                 \
     assert (v->size > 0 && v->ptr != NULL);                             \
+    assert (i < v->size);                                               \
     if (dest)                                                           \
       M_DO_MOVE (oplist, *dest, v->ptr[i]);                             \
     else                                                                \
-      M_GET_CLEAR oplist (v->ptr[i]);                                   \
+      M_CALL_CLEAR(oplist, v->ptr[i]);                                  \
     memmove(&v->ptr[i], &v->ptr[i+1], sizeof(type)*(v->size - i) );     \
     v->size--;                                                          \
     ARRAYI_CONTRACT(v);                                                 \
+  }                                                                     \
+  									\
+  static inline bool                                                    \
+  M_C(name, _erase)(array_t a, size_t i)                                \
+  {                                                                     \
+    ARRAYI_CONTRACT(a);                                                 \
+    if (i >= a->size) return false;                                     \
+    M_C(name, _pop_at)(NULL, a, i);                                     \
+    return true;                                                        \
   }                                                                     \
                                                                         \
+  M_IF_METHOD(INIT, oplist)(                                            \
   static inline void                                                    \
   M_C(name, _insert_v)(array_t v, size_t i, size_t num)			\
   {                                                                     \
     ARRAYI_CONTRACT(v);                                                 \
     assert(i <= v->size);                                               \
     size_t size = v->size + num;                                        \
+    /* Test for overflow of variable size */                            \
+    if (M_UNLIKELY (size <= v->size)) {                                 \
+      /* Unlikely case of nothing to do */                              \
+      if (num == 0) return;                                             \
+      M_MEMORY_FULL(sizeof (type) * v->size);                           \
+      return ;                                                          \
+    }                                                                   \
+    /* Test if alloc array is sufficient */                             \
     if (size > v->alloc) {                                              \
-      size_t alloc = M_GET_INC_ALLOC oplist (size) ;                    \
-      if (M_UNLIKELY (alloc <= v->alloc)) {				\
+      size_t alloc = M_CALL_INC_ALLOC(oplist, size) ;                   \
+      if (M_UNLIKELY (alloc <= v->alloc)) {                             \
         M_MEMORY_FULL(sizeof (type) * alloc);                           \
         return ;                                                        \
       }                                                                 \
-      type *ptr = M_GET_REALLOC oplist (type, v->ptr, alloc);           \
+      type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, alloc);          \
       if (M_UNLIKELY (ptr == NULL) ) {                                  \
         M_MEMORY_FULL(sizeof (type) * alloc);                           \
         return;                                                         \
@@ -444,10 +554,11 @@
     }                                                                   \
     memmove(&v->ptr[i+num], &v->ptr[i], sizeof(type)*(v->size - i) );   \
     for(size_t k = i ; k < i+num; k++)                                  \
-      M_GET_INIT oplist(v->ptr[k]);                                     \
+      M_CALL_INIT(oplist, v->ptr[k]);                                   \
     v->size = size;                                                     \
     ARRAYI_CONTRACT(v);                                                 \
   }                                                                     \
+  , /* No INIT */)                                                      \
                                                                         \
   static inline void                                                    \
   M_C(name, _remove_v)(array_t v, size_t i, size_t j)			\
@@ -455,7 +566,7 @@
     ARRAYI_CONTRACT(v);                                                 \
     assert(i < v->size && j <= v->size && i < j && v->ptr != NULL);     \
     for(size_t k = i ; k < j; k++)                                      \
-      M_GET_CLEAR oplist(v->ptr[k]);                                    \
+      M_CALL_CLEAR(oplist, v->ptr[k]);                                  \
     memmove(&v->ptr[i], &v->ptr[j], sizeof(type)*(v->size - j) );       \
     v->size -= (j-i);                                                   \
     ARRAYI_CONTRACT(v);                                                 \
@@ -485,16 +596,9 @@
     ARRAYI_CONTRACT(v);                                                 \
     assert(i < v->size && j < v->size && v->ptr != NULL);               \
     type tmp;                                                           \
-    M_IF_METHOD(INIT_MOVE, oplist) (                                    \
-    M_GET_INIT_MOVE oplist (tmp, v->ptr[i]);                            \
-    M_GET_INIT_MOVE oplist (v->ptr[i], v->ptr[j]);                      \
-    M_GET_INIT_MOVE oplist (v->ptr[j], tmp);                            \
-                                    ,                                   \
-    M_GET_INIT_SET oplist (tmp, v->ptr[i]);                             \
-    M_GET_SET oplist(v->ptr[i], v->ptr[j]);                             \
-    M_GET_SET oplist(v->ptr[j], tmp);                                   \
-    M_GET_CLEAR oplist(tmp);                                            \
-    ) /* IF INIT_MOVE method */                                         \
+    M_DO_INIT_MOVE(oplist, tmp, v->ptr[i]);                             \
+    M_DO_INIT_MOVE(oplist, v->ptr[i], v->ptr[j]);                       \
+    M_DO_INIT_MOVE(oplist, v->ptr[j], tmp);                             \
     ARRAYI_CONTRACT(v);                                                 \
   }                                                                     \
                                                                         \
@@ -506,7 +610,7 @@
     return &v->ptr[i];                                                  \
   }                                                                     \
                                                                         \
-  static inline const type *                                            \
+  static inline type const *                                            \
   M_C(name, _cget)(const array_t v, size_t i)                           \
   {                                                                     \
     ARRAYI_CONTRACT(v);                                                 \
@@ -514,8 +618,16 @@
     return M_CONST_CAST(type, &v->ptr[i]);                              \
   }                                                                     \
                                                                         \
+  static inline type const *                                            \
+  M_C(name, _front)(const array_t v)                                    \
+  {                                                                     \
+    ARRAYI_CONTRACT(v);                                                 \
+    assert (v->size > 0);                                               \
+    return M_C(name, _cget)(v, 0);                                      \
+  }                                                                     \
+                                                                        \
   static inline void                                                    \
-  M_C(name, _it)(array_it_t it, const array_t v)			\
+  M_C(name, _it)(it_t it, const array_t v)                              \
   {                                                                     \
     ARRAYI_CONTRACT(v);                                                 \
     assert (it != NULL);                                                \
@@ -524,7 +636,7 @@
   }                                                                     \
                                                                         \
   static inline void                                                    \
-  M_C(name, _it_last)(array_it_t it, const array_t v)			\
+  M_C(name, _it_last)(it_t it, const array_t v)                         \
   {                                                                     \
     ARRAYI_CONTRACT(v);                                                 \
     assert (it != NULL);                                                \
@@ -533,7 +645,7 @@
   }                                                                     \
                                                                         \
   static inline void                                                    \
-  M_C(name, _it_end)(array_it_t it, const array_t v)			\
+  M_C(name, _it_end)(it_t it, const array_t v)                          \
   {                                                                     \
     ARRAYI_CONTRACT(v);                                                 \
     assert (it != NULL);                                                \
@@ -542,7 +654,7 @@
   }                                                                     \
                                                                         \
   static inline void                                                    \
-  M_C(name, _it_set)(array_it_t it, const array_it_t org)		\
+  M_C(name, _it_set)(it_t it, const it_t org)                           \
   {                                                                     \
     assert (it != NULL && org != NULL);                                 \
     it->index = org->index;                                             \
@@ -551,14 +663,14 @@
   }                                                                     \
                                                                         \
   static inline bool                                                    \
-  M_C(name, _end_p)(const array_it_t it)				\
+  M_C(name, _end_p)(const it_t it)                                      \
   {                                                                     \
     assert(it != NULL && it->array != NULL);                            \
     return it->index >= it->array->size;                                \
   }                                                                     \
   									\
   static inline bool                                                    \
-  M_C(name, _last_p)(const array_it_t it)				\
+  M_C(name, _last_p)(const it_t it)                                     \
   {                                                                     \
     assert(it != NULL && it->array != NULL);                            \
     /* NOTE: Can not compute 'size-1' due to potential overflow         \
@@ -567,22 +679,22 @@
   }                                                                     \
   									\
   static inline bool                                                    \
-  M_C(name, _it_equal_p)(const array_it_t it1,				\
-			 const array_it_t it2)				\
+  M_C(name, _it_equal_p)(const it_t it1,				\
+			 const it_t it2)				\
   {                                                                     \
     assert(it1 != NULL && it2 != NULL);                                 \
     return it1->array == it2->array && it1->index == it2->index;        \
   }                                                                     \
   									\
   static inline void                                                    \
-  M_C(name, _next)(array_it_t it)					\
+  M_C(name, _next)(it_t it)                                             \
   {                                                                     \
     assert(it != NULL && it->array != NULL);                            \
     it->index ++;                                                       \
   }                                                                     \
   									\
   static inline void                                                    \
-  M_C(name, _previous)(array_it_t it)					\
+  M_C(name, _previous)(it_t it)                                         \
   {                                                                     \
     assert(it != NULL && it->array != NULL);                            \
     /* NOTE: In the case index=0, it will be set to (unsigned) -1       \
@@ -591,28 +703,28 @@
   }                                                                     \
   									\
   static inline type *                                                  \
-  M_C(name, _ref)(const array_it_t it)					\
+  M_C(name, _ref)(const it_t it)					\
   {                                                                     \
     assert(it != NULL);                                                 \
     return M_C(name, _get)(it->array, it->index);			\
   }                                                                     \
   									\
-  static inline const type *                                            \
-  M_C(name, _cref)(const array_it_t it)					\
+  static inline type const *                                            \
+  M_C(name, _cref)(const it_t it)					\
   {                                                                     \
     assert(it != NULL);                                                 \
     return M_C(name, _cget)(it->array, it->index);			\
   }                                                                     \
   									\
   static inline void                                                    \
-  M_C(name, _insert)(array_t a, array_it_t it, type const x)		\
+  M_C(name, _insert)(array_t a, it_t it, type const x)                  \
   {                                                                     \
     assert (it != NULL && a == it->array);                              \
     M_C(name, _push_at)(a, it->index + 1, x);				\
   }                                                                     \
   									\
   static inline void                                                    \
-  M_C(name, _remove)(array_t a, array_it_t it)				\
+  M_C(name, _remove)(array_t a, it_t it)				\
   {                                                                     \
     assert (it != NULL && a == it->array);                              \
     M_C(name, _pop_at)(NULL, a, it->index);				\
@@ -622,7 +734,7 @@
   M_IF_METHOD(CMP, oplist)                                              \
   (                                                                     \
    static inline void M_C(name, _special_sort)(array_t l,		\
-	      int (*func_type) (const type *a, const type *b))	        \
+	      int (*func_type) (type const *a, type const *b))	        \
   {                                                                     \
     /* Using qsort is more compact but slower than a full templated     \
        version which can be twice faster */                             \
@@ -641,7 +753,7 @@
     assert (size > 1);                                                  \
     /* Let's select the threshold of the pass 1 to be sure              \
        the final result is in tab.*/                                    \
-    if (m_core_clz(size-1) & 1)                                         \
+    if (m_core_clz64(size-1) & 1)					\
       th += th;                                                         \
                                                                         \
     /* Pass 1: insertion sort (stable) */                               \
@@ -650,8 +762,8 @@
       M_ASSUME(max >= th);                                              \
       for(size_t i = 1; i < max; i++) {                                 \
         size_t j = i;                                                   \
-        while (j > 0 && M_GET_CMP oplist (tab[k+j-1], tab[k+j]) > 0) {  \
-          M_GET_SWAP oplist (tab[k+j-1], tab[k+j]);                     \
+        while (j > 0 && M_CALL_CMP(oplist, tab[k+j-1], tab[k+j]) > 0) { \
+          M_CALL_SWAP(oplist, tab[k+j-1], tab[k+j]);                    \
           j = j - 1;                                                    \
         }                                                               \
       }                                                                 \
@@ -672,8 +784,8 @@
         assert (0 < n2 && n2 <= size);                                  \
         k += n1+n2;                                                     \
         for (;;) {                                                      \
-          if (M_GET_CMP oplist (*el1, *el2) <= 0) {                     \
-            M_GET_SET oplist (*dest, *el1);                             \
+          if (M_CALL_CMP(oplist, *el1, *el2) <= 0) {                    \
+            M_CALL_SET(oplist, *dest, *el1);                            \
             dest++;                                                     \
             el1++;                                                      \
             if (-- n1 == 0) {                                           \
@@ -684,7 +796,7 @@
               break;                                                    \
             }                                                           \
           } else {                                                      \
-            M_GET_SET oplist (*dest, *el2);                             \
+            M_CALL_SET(oplist, *dest, *el2);                            \
             dest++;                                                     \
             el2++;                                                      \
             if (-- n2 == 0) {                                           \
@@ -710,32 +822,33 @@
   {                                                                     \
     if (M_UNLIKELY (l->size < 2))                                       \
       return;                                                           \
-    type *temp = M_GET_REALLOC oplist (type, NULL, l->size);            \
+    type *temp = M_CALL_REALLOC(oplist, type, NULL, l->size);           \
     if (temp == NULL) {                                                 \
       M_MEMORY_FULL(sizeof (type) * l->size);                           \
       return ;                                                          \
     }                                                                   \
     M_C(name, _special_stable_sort_noalloc)(l->ptr, l->size, temp);     \
-    M_GET_FREE oplist(temp);                                            \
+    M_CALL_FREE(oplist, temp);                                          \
   }                                                                     \
   ,) /* IF SWAP method */                                               \
                                                                         \
   ,) /* IF CMP oplist */                                                \
   									\
+                                                                        \
   M_IF_METHOD(GET_STR, oplist)(                                         \
   static inline void                                                    \
-  M_C(name, _get_str)(string_t str, array_t array,			\
+  M_C(name, _get_str)(string_t str, array_t const array,                \
 		      bool append)					\
   {                                                                     \
     STRINGI_CONTRACT(str);                                              \
     ARRAYI_CONTRACT(array);                                             \
     (append ? string_cat_str : string_set_str) (str, "[");              \
-    array_it_t it;                                                      \
+    it_t it;                                                            \
     for (M_C(name, _it)(it, array) ;					\
          !M_C(name, _end_p)(it);					\
          M_C(name, _next)(it)){						\
-      const type *item = M_C(name, _cref)(it);				\
-      M_GET_GET_STR oplist (str, *item, true);                          \
+      type const *item = M_C(name, _cref)(it);				\
+      M_CALL_GET_STR(oplist, str, *item, true);                         \
       if (!M_C(name, _last_p)(it))					\
         string_push_back (str, M_GET_SEPARATOR oplist);                 \
     }                                                                   \
@@ -752,8 +865,8 @@
     assert (file != NULL);                                              \
     fputc ('[', file);                                                  \
     for (size_t i = 0; i < array->size; i++) {                          \
-      const type *item = M_C(name, _cget)(array, i);			\
-      M_GET_OUT_STR oplist (file, *item);                               \
+      type const *item = M_C(name, _cget)(array, i);			\
+      M_CALL_OUT_STR(oplist, file, *item);                              \
       if (i != array->size-1)                                           \
         fputc (M_GET_SEPARATOR oplist, file);                           \
     }                                                                   \
@@ -761,7 +874,39 @@
   }                                                                     \
   , /* no OUT_STR */ )                                                  \
                                                                         \
-  M_IF_METHOD(IN_STR, oplist)(                                          \
+  M_IF_METHOD2(PARSE_STR, INIT, oplist)(                                \
+  static inline bool                                                    \
+  M_C(name, _parse_str)(array_t array, const char str[], const char**endp) \
+  {                                                                     \
+    ARRAYI_CONTRACT(array);                                             \
+    assert (str != NULL);                                               \
+    M_C(name,_clean)(array);                                            \
+    bool success = false;                                               \
+    int c = *str++;                                                     \
+    if (M_UNLIKELY (c != '[')) goto exit;                               \
+    c = *str++;                                                         \
+    if (M_UNLIKELY (c == ']')) { success = true; goto exit; }           \
+    if (M_UNLIKELY (c == 0)) goto exit;                                 \
+    str--;                                                              \
+    type item;                                                          \
+    M_CALL_INIT(oplist, item);                                          \
+    do {                                                                \
+      bool b = M_CALL_PARSE_STR(oplist, item, str, &str);               \
+      do { c = *str++; } while (isspace(c));                            \
+      if (b == false || c == 0) { goto exit_clear; }                    \
+      M_C(name, _push_back)(array, item);                               \
+    } while (c == M_GET_SEPARATOR oplist);                              \
+    ARRAYI_CONTRACT(array);                                             \
+    success = (c == ']');                                               \
+  exit_clear:                                                           \
+    M_CALL_CLEAR(oplist, item);                                         \
+  exit:                                                                 \
+    if (endp) *endp = str;                                              \
+    return success;                                                     \
+  }                                                                     \
+  , /* no PARSE_STR & INIT */ )                                         \
+                                                                        \
+  M_IF_METHOD2(IN_STR, INIT, oplist)(                                   \
   static inline bool                                                    \
   M_C(name, _in_str)(array_t array, FILE *file)				\
   {                                                                     \
@@ -775,18 +920,64 @@
     if (M_UNLIKELY (c == EOF)) return false;                            \
     ungetc(c, file);                                                    \
     type item;                                                          \
-    M_GET_INIT oplist (item);                                           \
+    M_CALL_INIT(oplist, item);                                          \
     do {                                                                \
-      bool b = M_GET_IN_STR oplist (item, file);                        \
-      c = fgetc(file);                                                  \
+      bool b = M_CALL_IN_STR(oplist, item, file);                       \
+      do { c = fgetc(file); } while (isspace(c));                       \
       if (b == false || c == EOF) { break; }				\
       M_C(name, _push_back)(array, item);				\
     } while (c == M_GET_SEPARATOR oplist);				\
-    M_GET_CLEAR oplist (item);                                          \
+    M_CALL_CLEAR(oplist, item);                                         \
     ARRAYI_CONTRACT(array);                                             \
     return c == ']';                                                    \
   }                                                                     \
-  , /* no IN_STR */ )                                                   \
+  , /* no IN_STR & INIT */ )                                            \
+                                                                        \
+  M_IF_METHOD(OUT_SERIAL, oplist)(                                      \
+  static inline m_serial_return_code_t                                  \
+  M_C(name, _out_serial)(m_serial_write_t f, const array_t array)       \
+  {                                                                     \
+    ARRAYI_CONTRACT(array);                                             \
+    assert (f != NULL && f->m_interface != NULL);                         \
+    m_serial_return_code_t ret;                                         \
+    m_serial_local_t local;                                             \
+    ret = f->m_interface->write_array_start(local, f, array->size);       \
+    for (size_t i = 0; i < array->size; i++) {                          \
+      type const *item = M_C(name, _cget)(array, i);			\
+      if (i != 0)                                                       \
+        ret |= f->m_interface->write_array_next(local, f);                \
+      ret |= M_CALL_OUT_SERIAL(oplist, f, *item);                       \
+    }                                                                   \
+    ret |= f->m_interface->write_array_end(local, f);                     \
+    return ret & M_SERIAL_FAIL;                                         \
+  }                                                                     \
+  , /* no OUT_SERIAL */ )                                               \
+                                                                        \
+  M_IF_METHOD2(IN_SERIAL, INIT, oplist)(                                \
+  static inline m_serial_return_code_t                                  \
+  M_C(name, _in_serial)(array_t array, m_serial_read_t f)               \
+  {                                                                     \
+    ARRAYI_CONTRACT(array);                                             \
+    assert (f != NULL && f->m_interface != NULL);                         \
+    m_serial_return_code_t ret;                                         \
+    m_serial_local_t local;                                             \
+    size_t estimated_size = 0;                                          \
+    M_C(name,_clean)(array);						\
+    ret = f->m_interface->read_array_start(local, f, &estimated_size);    \
+    if (M_UNLIKELY (ret != M_SERIAL_OK_CONTINUE)) return ret;           \
+    if (estimated_size != 0) M_C(name, _reserve)(array, estimated_size); \
+    type item;                                                          \
+    M_CALL_INIT(oplist, item);                                          \
+    do {                                                                \
+      ret = M_CALL_IN_SERIAL(oplist, item, f);                          \
+      if (ret != M_SERIAL_OK_DONE) { break; }				\
+      M_C(name, _push_back)(array, item);				\
+    } while ((ret = f->m_interface->read_array_next(local, f)) == M_SERIAL_OK_CONTINUE); \
+    M_CALL_CLEAR(oplist, item);                                         \
+    ARRAYI_CONTRACT(array);                                             \
+    return ret;                                                         \
+  }                                                                     \
+  , /* no IN_SERIAL & INIT */ )                                         \
                                                                         \
   M_IF_METHOD(EQUAL, oplist)(                                           \
   static inline bool                                                    \
@@ -798,9 +989,9 @@
     if (array1->size != array2->size) return false;                     \
     size_t i;                                                           \
     for(i = 0; i < array1->size; i++) {                                 \
-      const type *item1 = M_C(name, _cget)(array1, i);			\
-      const type *item2 = M_C(name, _cget)(array2, i);			\
-      bool b = M_GET_EQUAL oplist (*item1, *item2);                     \
+      type const *item1 = M_C(name, _cget)(array1, i);			\
+      type const *item2 = M_C(name, _cget)(array2, i);			\
+      bool b = M_CALL_EQUAL(oplist, *item1, *item2);                    \
       if (!b) return false;                                             \
     }                                                                   \
     return i == array1->size;                                           \
@@ -814,11 +1005,32 @@
     ARRAYI_CONTRACT(array);                                             \
     M_HASH_DECL(hash);                                                  \
     for(size_t i = 0 ; i < array->size; i++) {                          \
-      size_t hi = M_GET_HASH oplist (array->ptr[i]);                    \
+      size_t hi = M_CALL_HASH(oplist, array->ptr[i]);                   \
       M_HASH_UP(hash, hi);                                              \
     }                                                                   \
     return M_HASH_FINAL (hash);						\
   }                                                                     \
   , /* no HASH */ )                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _splice)(array_t a1, array_t a2)  			        \
+  {                                                                     \
+    ARRAYI_CONTRACT(a1);                                                \
+    ARRAYI_CONTRACT(a2);                                                \
+    if (M_LIKELY (a2->size > 0)) {                                      \
+      size_t newSize = a1->size + a2->size;                             \
+      if (newSize > a1->alloc) {                                        \
+        type *ptr = M_CALL_REALLOC(oplist, type, a1->ptr, newSize);     \
+        if (M_UNLIKELY (ptr == NULL) ) {                                \
+          M_MEMORY_FULL(sizeof (type) * newSize);                       \
+        }                                                               \
+        a1->ptr = ptr;                                                  \
+        a1->alloc = newSize;                                            \
+      }                                                                 \
+      memcpy(&a1->ptr[a1->size], &a2->ptr[0], a2->size * sizeof (type)); \
+      a2->size = 0;                                                     \
+      a1->size = newSize;                                               \
+    }                                                                   \
+  }                                                                     \
 
 #endif

m-atomic.h

@@ -1,7 +1,7 @@
 /*
  * M*LIB - Thin stdatomic wrapper for C++ compatibility
  *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2020, 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:
@@ -22,8 +22,8 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#ifndef __M_ATOMIC_H
-#define __M_ATOMIC_H
+#ifndef MSTARLIB_ATOMIC_H
+#define MSTARLIB_ATOMIC_H
 
 /* NOTE: Due to the C++ not having recognized stdatomic.h officialy,
    it is hard to use this header directly with a C++ compiler like 
@@ -89,16 +89,41 @@ using std::atomic_flag_test_and_set_explicit;
 using std::atomic_flag_clear;
 using std::atomic_flag_clear_explicit;
 
+using std::memory_order_relaxed;
+using std::memory_order_consume;
+using std::memory_order_acquire;
+using std::memory_order_release;
+using std::memory_order_acq_rel;
+using std::memory_order_seq_cst;
+
 #define _Atomic(T) std::atomic< T >
 
-#elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L)	\
-  || ( defined(__GNUC__) && !defined(__clang__) && !defined(__cplusplus) && (__GNUC__*100 + __GNUC_MINOR__) >= 409) \
-  || (defined(__clang__) && __clang_major__ >= 4)
+#elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L)        \
+  || ( defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__cplusplus) && (__GNUC__*100 + __GNUC_MINOR__) >= 409) \
+  || (defined(__clang__) && __clang_major__ >= 4)			\
+  || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1800)
 
-/* CLANG 3.5 has issues with GCC's stdatomic.h
-   and doesn't provide its own stdatomic.h */
+/* C11 has mandatory working stdatomic
+   STDATOMIC doesn't work with C++ except for clang
+   GCC < 4.9 doesn't provide a compliant stdatomic.h
+   CLANG 3.5 has issues with GCC's stdatomic.h
+   and doesn't provide its own stdatomic.h
+   ICC < 18 doesn't provide a compliant stdatomic.h
+*/
 #include <stdatomic.h>
 
+/* MSYS2 has a conflict between cdefs.h which defines a _Atomic macro (if not C11)
+   not compatible with the used stdatomic.h (from GCC).
+   Provide a configurable mechanism to undef it with auto-detection of msys2 / gcc */
+#ifndef M_USE_UNDEF_ATOMIC
+# if defined(__MSYS__) && defined(__GNUC__) && (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112L)
+#  define M_USE_UNDEF_ATOMIC 1
+# endif
+#endif
+#if defined(M_USE_UNDEF_ATOMIC) && M_USE_UNDEF_ATOMIC == 1
+# undef _Atomic
+#endif
+
 #else
 
 /* Non working atomic.h, nor working stdatomic.h found.
@@ -110,21 +135,24 @@ using std::atomic_flag_clear_explicit;
 */
 #include "m-mutex.h"
 
-/* The structure is quite large:
-   __val     : value of the atomic type,
-   __zero    : zero value of the atomic type (constant),
-   __previous: temporary value used within the mutex lock,
-   __lock    : the mutex lock.
+/* _Atomic qualifier for a type (emulation).
+  The structure is quite large:
+   _val     : value of the atomic type,
+   _zero    : zero value of the atomic type (constant),
+   _previous: temporary value used within the mutex lock,
+   _lock    : the mutex lock.
+  Support up to sizeof (long long) type.
  */
 #define	_Atomic(T)                              \
   struct {                                      \
-    volatile T __val;                           \
-    T          __zero;                          \
-    T          __previous;                      \
-    m_mutex_t  __lock;                          \
+    T volatile _val;                            \
+    T          _zero;                           \
+    T          _previous;                       \
+    m_mutex_t  _lock;                           \
   }
 
-/* Even memory order is defined, only the strongest constraint is used */
+/* Define the supported memory order.
+   Even if memory order is defined, only the strongest constraint is used */
 typedef enum {
   memory_order_relaxed,
   memory_order_consume,
@@ -152,7 +180,7 @@ typedef _Atomic(size_t)             atomic_size_t;
 typedef _Atomic(ptrdiff_t)          atomic_ptrdiff_t;
 
 /* Define the minimum size supported by the architecture
-   for atomic read or write.
+   for an atomic read or write.
    This can help a lot since it avoids locking for atomic_load and
    atomic_store.
 */
@@ -168,74 +196,94 @@ typedef _Atomic(ptrdiff_t)          atomic_ptrdiff_t;
 #if (defined (INTMAX_C) && defined (UINTMAX_C) && !defined(__cplusplus)) || \
   defined (_STDINT_H) || defined (_STDINT_H_) || defined (_STDINT) ||   \
   defined (_SYS_STDINT_H_)
+/* Define additional atomic types */
 typedef _Atomic(intmax_t)           atomic_intmax_t;
 typedef _Atomic(uintmax_t)          atomic_uintmax_t;
 #endif
 
-/* Unlock the mutex and return the given value */
+/* (INTERNAL) Unlock the mutex and return the given value */
 static inline long long atomic_fetch_unlock (m_mutex_t *lock, long long val)
 {
   m_mutex_unlock (*lock);
   return val;
 }
 
-/* This is the heart of the wrapper:
+/* (INTERNAL) This is the heart of the wrapper:
    lock the atomic value, read it and returns the value.
    In order to avoid any compiler extension, we need to transform the
    atomic type into 'long long' then convert it back to its value.
-   This is because __previous can't be read after the lock, and we can't
+   This is because _previous can't be read after the lock, and we can't
    generate temporary variable within a macro.
    The trick is computing _val - _zero within the lock, then
-   returns retvalue + _zero after the lock.
+   returns retvalue + _zero after the release of the lock.
 */
 #define atomic_fetch_op(ptr, val, op)                                   \
-  (m_mutex_lock((ptr)->__lock),                                         \
-   (ptr)->__previous = (ptr)->__val,                                    \
-   (ptr)->__val op (val),                                               \
-   atomic_fetch_unlock(&(ptr)->__lock, (ptr)->__previous-(ptr)->__zero)+(ptr)->__zero)
+  (m_mutex_lock((ptr)->_lock),                                          \
+   (ptr)->_previous = (ptr)->_val,                                      \
+   (ptr)->_val op (val),                                                \
+   atomic_fetch_unlock(&(ptr)->_lock, (ptr)->_previous-(ptr)->_zero)+(ptr)->_zero)
 
+/* Perform an atomic add (EMULATION) */
 #define atomic_fetch_add(ptr, val) atomic_fetch_op(ptr, val, +=)
+/* Perform an atomic sub (EMULATION) */
 #define atomic_fetch_sub(ptr, val) atomic_fetch_op(ptr, val, -=)
+/* Perform an atomic or (EMULATION) */
 #define atomic_fetch_or(ptr, val)  atomic_fetch_op(ptr, val, |=)
+/* Perform an atomic xor (EMULATION) */
 #define atomic_fetch_xor(ptr, val) atomic_fetch_op(ptr, val, ^=)
+/* Perform an atomic and (EMULATION) */
 #define atomic_fetch_and(ptr, val) atomic_fetch_op(ptr, val, &=)
+/* Perform an atomic exchange (EMULATION) */
 #define atomic_exchange(ptr, val)  atomic_fetch_op(ptr, val, =)
 
+/* Initialize an atomic GLOBAL variable */
 #define ATOMIC_VAR_INIT(val) { val, 0, 0, M_MUTEXI_INIT_VALUE }
 
+/* Initialize an atomic variable */
 #define atomic_init(ptr, val)                                           \
-  (m_mutex_init((ptr)->__lock), (ptr)->__val = val, (ptr)->__zero = 0)
+  (m_mutex_init((ptr)->_lock), (ptr)->_val = val, (ptr)->_zero = 0)
 
+/* (INTERNAL) Load an atomic variable within a lock
+   (needed for variable greater than CPU atomic size) */
 #define atomic_load_lock(ptr)                                           \
-  (m_mutex_lock((ptr)->__lock),                                         \
-   (ptr)->__previous = (ptr)->__val,                                    \
-   atomic_fetch_unlock(&(ptr)->__lock, (ptr)->__previous-(ptr)->__zero)+(ptr)->__zero)
+  (m_mutex_lock((ptr)->_lock),                                          \
+   (ptr)->_previous = (ptr)->_val,                                      \
+   atomic_fetch_unlock(&(ptr)->_lock, (ptr)->_previous-(ptr)->_zero)+(ptr)->_zero)
 
+/* (INTERNAL) Store an atomic variable within a lock
+   (needed for variable greater than CPU atomic size) */
 #define atomic_store_lock(ptr, val)                                     \
-  (m_mutex_lock((ptr)->__lock),                                         \
-   (ptr)->__val = (val),                                                \
-   m_mutex_unlock((ptr)->__lock))
+  (m_mutex_lock((ptr)->_lock),                                          \
+   (ptr)->_val = (val),                                                 \
+   m_mutex_unlock((ptr)->_lock))
 
+/* Atomic load of a variable (EMULATION)
+   If the atomic type size is not greater than the CPU atomic size,
+   we can perform a direct read of the variable (much faster) */
 #define atomic_load(ptr)                                                \
-  ( sizeof ((ptr)->__val) <= ATOMICI_MIN_RW_SIZE                        \
-    ? (ptr)->__val                                                      \
+  ( sizeof ((ptr)->_val) <= ATOMICI_MIN_RW_SIZE                         \
+    ? (ptr)->_val                                                       \
     : atomic_load_lock(ptr))
-
+  
+/* Atomic store of a variable (EMULATION)
+   If the atomic type size is not greater than the CPU atomic size,
+   we can perform a direct write of the variable (much faster) */
 #define atomic_store(ptr, val) do {                                     \
-    if ( sizeof ((ptr)->__val) <= ATOMICI_MIN_RW_SIZE) {                \
-      (ptr)->__val = (val);                                             \
+    if ( sizeof ((ptr)->_val) <= ATOMICI_MIN_RW_SIZE) {                 \
+      (ptr)->_val = (val);                                              \
     } else {                                                            \
-      long long _offset = (val) - (ptr)->__zero;                        \
-      atomic_store_lock(ptr, (ptr)->__zero + _offset);                  \
+      long long _offset = (val) - (ptr)->_zero;                         \
+      atomic_store_lock(ptr, (ptr)->_zero + _offset);                   \
     }                                                                   \
   } while (0)
 
-#define atomic_compare_exchange_strong(ptr, exp, val)                   \
-  (m_mutex_lock((ptr)->__lock),                                         \
-   atomic_fetch_unlock(&(ptr)->__lock,                                  \
-                       (ptr)->__val == *(exp)                           \
-                       ? ((ptr)->__val = (val), true)                   \
-                       : (*(exp) = (ptr)->__val, false)))
+/* Perform a CAS (Compare and swap) operation (EMULATION) */
+#define atomic_compare_exchange_strong(ptr, exp, val)                  \
+  (m_mutex_lock((ptr)->_lock),                                         \
+   atomic_fetch_unlock(&(ptr)->_lock,                                  \
+                       (ptr)->_val == *(exp)                           \
+                       ? ((ptr)->_val = (val), true)                   \
+                       : (*(exp) = (ptr)->_val, false)))
 
   
 #define atomic_fetch_add_explicit(ptr, val, mem) atomic_fetch_op(ptr, val, +=)
@@ -250,11 +298,11 @@ static inline long long atomic_fetch_unlock (m_mutex_t *lock, long long val)
 #define atomic_thread_fence(mem)                 (void) 0
 #define atomic_signal_fence(mem)                 (void) 0
 #define atomic_is_lock_free(ptr)                 false
-#define atomic_compare_exchange_strong_explicit(ptr, exp, val, mem) atomic_compare_exchange_strong(ptr, exp, val)
-#define atomic_compare_exchange_weak_explicit(ptr, exp, val, mem)   atomic_compare_exchange_strong(ptr, exp, val)
-#define atomic_compare_exchange_weak(ptr, exp, val)                 atomic_compare_exchange_strong(ptr, exp, val)
+#define atomic_compare_exchange_strong_explicit(ptr, exp, val, mem1, mem2) atomic_compare_exchange_strong(ptr, exp, val)
+#define atomic_compare_exchange_weak_explicit(ptr, exp, val, mem1, mem2)   atomic_compare_exchange_strong(ptr, exp, val)
+#define atomic_compare_exchange_weak(ptr, exp, val)                        atomic_compare_exchange_strong(ptr, exp, val)
 
-/* TODO: Missing atomic_flag. Problem: it needs to be lock free! */
+/* TODO: Missing atomic_flag. Problem: it is supposed to be lock free! */
 
 #endif
 

m-bitset.h

@@ -1,7 +1,7 @@
 /*
  * M*LIB - BITSET module
  *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2020, 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:
@@ -22,38 +22,29 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#ifndef __M_BITSET_H
-#define __M_BITSET_H
+#ifndef MSTARLIB_BITSET_H
+#define MSTARLIB_BITSET_H
 
+#include <stdint.h>
 #include "m-core.h"
 
 /********************************** INTERNAL ************************************/
 
-// Define a limb of a bitset
-typedef unsigned long bitset_limb;
+// Define the limb of a bitset
+typedef uint64_t bitset_limb;
+// And its size
 #define BITSET_LIMB_BIT (sizeof(bitset_limb) * CHAR_BIT)
 
-typedef struct bitset_s {
-  size_t size;            // Size is the number of bits
-  size_t alloc;           // Alloc is the number of allocated limbs
-  bitset_limb *ptr;       // Pointer to the allocated limbs
-} bitset_t[1];
-
-typedef struct bitset_it_s {
-  size_t index;           // index to the array of bit
-  bool   value;           // value used for _ref & _cref to store the value
-  struct bitset_s *set;   // the associated bitset
-} bitset_it_t[1];
-
-// bitset grow policy
-#define BITSETI_INC_ALLOC_SIZE(n) ((n) < 2 ? 4 : (n) * 2)
+// bitset grow policy. n is limb size
+#define BITSETI_INC_ALLOC_SIZE(n) ((n) < 4 ? 4 : (n) * 2)
 
 // Compute the number of allocated limbs needed to handle 'n' bits.
 #define BITSETI_TO_ALLOC(n)       (((n) + BITSET_LIMB_BIT - 1) / BITSET_LIMB_BIT)
 
-// Compute the number of bits available from the allocated size
+// Compute the number of bits available from the allocated size in limbs
 #define BITSETI_FROM_ALLOC(n)     ((n) * BITSET_LIMB_BIT)
 
+// Contract of a bitset
 #define BITSETI_CONTRACT(t) do {					\
     assert (t != NULL);							\
     assert (t->size <= BITSETI_FROM_ALLOC (t->alloc));			\
@@ -65,12 +56,28 @@ typedef struct bitset_it_s {
 
 /********************************** EXTERNAL ************************************/
 
+typedef struct bitset_s {
+  size_t size;            // Size is the number of bits
+  size_t alloc;           // Alloc is the number of allocated limbs
+  bitset_limb *ptr;       // Pointer to the allocated limbs
+} bitset_t[1];
+
+typedef struct bitset_s *bitset_ptr;
+typedef const struct bitset_s *bitset_srcptr;
+
+typedef struct bitset_it_s {
+  size_t index;           // index to the array of bit
+  bool   value;           // value used for _ref & _cref to store the value
+  struct bitset_s *set;   // the associated bitset
+} bitset_it_t[1];
+
 static inline void
 bitset_init(bitset_t t)
 {
   assert (t != NULL);
   assert (M_POWEROF2_P(BITSET_LIMB_BIT));
-  t->size = t->alloc = 0;
+  t->size = 0;
+  t->alloc = 0;
   t->ptr = NULL;
   BITSETI_CONTRACT(t);
 }
@@ -148,7 +155,7 @@ bitset_set_at(bitset_t v, size_t i, bool x)
   const size_t offset = i / BITSET_LIMB_BIT;
   const size_t index  = i % BITSET_LIMB_BIT;
   // This is a branchless version as x can only be 0 or 1 with only one variable shift.
-  const size_t mask = (bitset_limb)1<<index;
+  const bitset_limb mask = ((bitset_limb)1)<<index;
   v->ptr[offset] = (v->ptr[offset] & ~mask) | (mask & (-(bitset_limb)x));
   BITSETI_CONTRACT (v);
 }
@@ -183,6 +190,7 @@ bitset_push_back (bitset_t v, bool x)
       return;
     }
     // Clear allocated memory
+    // FIXME: Why?
     for(size_t a = v->alloc; a < needAlloc; a++)
       ptr[a] = 0;
     v->ptr = ptr;
@@ -272,6 +280,14 @@ bitset_pop_back(bool *dest, bitset_t v)
   BITSETI_CONTRACT (v);
 }
 
+static inline bool
+bitset_front(bitset_t v)
+{
+  BITSETI_CONTRACT (v);
+  assert(v->size > 0);
+  return bitset_get(v, 0);
+}
+
 static inline bool
 bitset_back(bitset_t v)
 {
@@ -407,7 +423,7 @@ bitset_equal_p (const bitset_t set1, const bitset_t set2)
   /* Compare the last limb if needed */
   const size_t index = set1->size % BITSET_LIMB_BIT;
   if (index > 0) {
-    const size_t mask = (((bitset_limb)1) << index) - 1;
+    const bitset_limb mask = (((bitset_limb)1) << index) - 1;
     if ((set1->ptr[limbSize] & mask) != (set2->ptr[limbSize] & mask))
       return false;
   }
@@ -523,22 +539,32 @@ bitset_in_str(bitset_t set, FILE *file)
 }
 
 static inline bool
-bitset_set_str(bitset_t set, const char str[])
+bitset_parse_str(bitset_t set, const char str[], const char **endptr)
 {
   BITSETI_CONTRACT (set);
   assert(str != NULL);
+  bool success = false;
   bitset_clean(set);
   char c = *str++;
-  if (c != '[') return false;
+  if (c != '[') goto exit;
   c = *str++;
   do {
-    if (c != '0' && c != '1') return false;
+    if (c != '0' && c != '1') goto exit;
     const bool b = (c == '1');
     bitset_push_back (set, b);
     c = *str++;
   } while (c != ']' && c != 0);
   BITSETI_CONTRACT (set);
-  return c == ']';
+  success = (c == ']');
+ exit:
+  if (endptr) *endptr = str;
+  return success;
+}
+
+static inline bool
+bitset_set_str(bitset_t dest, const char str[])
+{
+  return bitset_parse_str(dest, str, NULL);
 }
 
 static inline void
@@ -552,7 +578,7 @@ bitset_and(bitset_t dest, const bitset_t src)
   for(size_t i = 0 ; i < n; i++)
     dest->ptr[i] &= src->ptr[i];
   if (m) {
-    size_t mask = (((bitset_limb)1) << m) - 1;
+    bitset_limb mask = (((bitset_limb)1) << m) - 1;
     dest->ptr[n] = (dest->ptr[n] & src->ptr[n]) & mask;
   }
   dest->size = s;
@@ -570,7 +596,7 @@ bitset_or(bitset_t dest, const bitset_t src)
   for(size_t i = 0 ; i < n; i++)
     dest->ptr[i] |= src->ptr[i];
   if (m) {
-    size_t mask = (((bitset_limb)1) << m) - 1;
+    bitset_limb mask = (((bitset_limb)1) << m) - 1;
     dest->ptr[n] = (dest->ptr[n] | src->ptr[n]) & mask;
   }
   dest->size = s;
@@ -588,7 +614,7 @@ bitset_xor(bitset_t dest, const bitset_t src)
   for(size_t i = 0 ; i < n; i++)
     dest->ptr[i] ^= src->ptr[i];
   if (m) {
-    size_t mask = (((bitset_limb)1) << m) - 1;
+    bitset_limb mask = (((bitset_limb)1) << m) - 1;
     dest->ptr[n] = (dest->ptr[n] ^ src->ptr[n]) & mask;
   }
   dest->size = s;
@@ -605,7 +631,7 @@ bitset_not(bitset_t dest)
   for(size_t i = 0 ; i < n; i++)
     dest->ptr[i] = ~ (dest->ptr[i]);
   if (m) {
-    size_t mask = (((bitset_limb)1) << m) - 1;
+    bitset_limb mask = (((bitset_limb)1) << m) - 1;
     dest->ptr[n] = (~ dest->ptr[n]) & mask;
   }
   dest->size = s;
@@ -613,25 +639,51 @@ bitset_not(bitset_t dest)
 }
 
 static inline size_t
-bitset_hash(const bitset_t dest)
+bitset_hash(const bitset_t set)
 {
-  BITSETI_CONTRACT(dest);
-  size_t s = dest->size;
+  BITSETI_CONTRACT(set);
+  size_t s = set->size;
   size_t n = s / BITSET_LIMB_BIT;
   size_t m = s % BITSET_LIMB_BIT;
   M_HASH_DECL(hash);
   for(size_t i = 0 ; i < n; i++)
-    M_HASH_UP(hash, dest->ptr[i]);
+    M_HASH_UP(hash, set->ptr[i]);
   if (m) {
-    size_t mask = (((bitset_limb)1) << m) - 1;
-    M_HASH_UP(hash, (dest->ptr[n] & mask));
+    bitset_limb mask = (((bitset_limb)1) << m) - 1;
+    M_HASH_UP(hash, (set->ptr[n] & mask));
   }
   return M_HASH_FINAL (hash);
 }
 
+static inline size_t
+bitset_clz(const bitset_t set)
+{
+  BITSETI_CONTRACT(set);
+  size_t s = set->size;
+  assert (s > 0);
+  size_t n = (s -1) / BITSET_LIMB_BIT;
+  size_t m = s % BITSET_LIMB_BIT;
+  bitset_limb limb = set->ptr[n];
+  if (m) {
+    bitset_limb mask = (((bitset_limb)1) << m) - 1;
+    limb &= mask;
+  } else {
+    m = BITSET_LIMB_BIT;
+  }
+  s = 0;
+  while (limb == 0 && n > 0) {
+    s += m;
+    limb = set->ptr[--n];
+    m = BITSET_LIMB_BIT;
+  }
+  s += m_core_clz64(limb) - (BITSET_LIMB_BIT - m);
+  return s;
+}
+
 #define BITSET_OPLIST                                                   \
   (INIT(bitset_init)                                                    \
    ,INIT_SET(bitset_init_set)                                           \
+   ,INIT_WITH(API_1(M_INIT_VAI))                                        \
    ,SET(bitset_set)                                                     \
    ,CLEAR(bitset_clear)                                                 \
    ,INIT_MOVE(bitset_init_move)                                         \
@@ -639,6 +691,8 @@ bitset_hash(const bitset_t dest)
    ,SWAP(bitset_swap)                                                   \
    ,TYPE(bitset_t)                                                      \
    ,SUBTYPE(bool)                                                       \
+   ,TEST_EMPTY(bitset_empty_p),                                         \
+   ,GET_SIZE(bitset_size)                                               \
    ,IT_TYPE(bitset_it_t)                                                \
    ,IT_FIRST(bitset_it)                                                 \
    ,IT_SET(bitset_it_set)                                               \
@@ -656,10 +710,12 @@ bitset_hash(const bitset_t dest)
    ,HASH(bitset_hash)                                                   \
    ,GET_STR(bitset_get_str)                                             \
    ,OUT_STR(bitset_out_str)                                             \
+   ,PARSE_STR(bitset_parse_str)                                         \
    ,IN_STR(bitset_in_str)                                               \
    ,EQUAL(bitset_equal_p)                                               \
    )
 
+/* Register the OPLIST as a global one */
 #define M_OPL_bitset_t() BITSET_OPLIST
 
 // TODO: set_at2, insert_v, remove_v
@@ -667,9 +723,9 @@ bitset_hash(const bitset_t dest)
 #endif
 
 // NOTE: Define this function only if m-string has been included
-#ifndef __M_BITSET_STRING_H
-#ifdef  __M_STRING_H
-#define __M_BITSET_STRING_H
+#ifndef MSTARLIB_BITSET_STRING_H
+#ifdef  MSTARLIB_STRING_H
+#define MSTARLIB_BITSET_STRING_H
 
 static inline void
 bitset_get_str(string_t str, const bitset_t set, bool append)

m-buffer.h

@@ -1,7 +1,7 @@
 /*
- * M*LIB - Fixed size BUFFER & STACK interface
+ * M*LIB - Fixed size (Bounded) QUEUE & STACK interface
  *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2020, 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:
@@ -22,19 +22,19 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#ifndef __M_BUFFER_H
-#define __M_BUFFER_H
+#ifndef MSTARLIB_BUFFER_H
+#define MSTARLIB_BUFFER_H
 
 #include "m-core.h"
 #include "m-mutex.h"
 #include "m-atomic.h"
 
-/* Define the different kind of policy a buffer can have:
+/* Define the different kind of policy a lock-based buffer can have:
  * - the buffer can be either a queue (policy is FIFO) or a stack (policy is FILO),
- * - if the push is blocking (waiting for the buffer to has some space) or not,
- * - if the pop is blocking (waiting for the buffer to has some space) or not,
- * - if both push / pop are blocking,
- * - if it shall be thread safe or not (i.e. remove mutex and atomic costs),
+ * - if the push method is by default blocking (waiting for the buffer to has some space) or not, *** deprecated ***
+ * - if the pop method is by default blocking (waiting for the buffer to has some data) or not, *** deprecated ***
+ * - if both methods are blocking, *** deprecated ***
+ * - if it shall be thread safe or not (i.e. remove the mutex lock and atomic costs),
  * - if the buffer has to be init with empty elements, or if it shall init an element when it is pushed (and moved when popped),
  * - if the buffer has to overwrite the last element if the buffer is full,
  * - if the pop of an element is not complete until the call to pop_release (preventing push until this call).
@@ -53,17 +53,24 @@ typedef enum {
 /* Define a lock based buffer.
    USAGE: BUFFER_DEF(name, type, size_of_buffer_or_0, policy[, oplist]) */
 #define BUFFER_DEF(name, type, m_size, ... )                            \
-  BUFFERI_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                               \
-              ((name, type, m_size,__VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__), M_C(name,_t)), \
+  BUFFERI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                            \
+              ((name, type, m_size,__VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(type)(), M_C(name,_t)), \
                (name, type, m_size,__VA_ARGS__,                                      M_C(name,_t))))
 
+/* Define the oplist of a lock based buffer given its name and its oplist.
+   USAGE: BUFFER_OPLIST(name[, oplist of the type]) */
+#define BUFFER_OPLIST(...)                                              \
+  BUFFERI_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                         \
+                 ((__VA_ARGS__, M_DEFAULT_OPLIST),			\
+                  (__VA_ARGS__ )))
+
 /* Define a lock-free queue for Many Producer Many Consummer
    Much faster than queue of BUFFER_DEF in heavy communication scenario
    Size of created queue can only a power of 2.
 */
 #define QUEUE_MPMC_DEF(name, type, ...)					\
-  QUEUEI_MPMC_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                           \
-                  ((name, type, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__), M_C(name,_t)), \
+  QUEUEI_MPMC_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
+                  ((name, type, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(type)(), M_C(name,_t)), \
                    (name, type, __VA_ARGS__,                                      M_C(name,_t))))
 
 /* Define a wait-free queue for Single Producer Single Consummer
@@ -71,11 +78,13 @@ typedef enum {
    Size of created queue can only a power of 2.
 */
 #define QUEUE_SPSC_DEF(name, type, ...)					\
-  QUEUEI_SPSC_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                           \
-                  ((name, type, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__), M_C(name,_t)), \
+  QUEUEI_SPSC_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
+                  ((name, type, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(type)(), M_C(name,_t)), \
                    (name, type, __VA_ARGS__,                                      M_C(name,_t))))
 
 
+
+
 /********************************** INTERNAL ************************************/
 
 #define BUFFERI_IF_CTE_SIZE(m_size)  M_IF(M_BOOL(m_size))
@@ -93,21 +102,43 @@ typedef enum {
     assert (atomic_load(&buffer->number[0]) <= BUFFERI_SIZE(size));	\
   } while (0)
 
-#define BUFFERI_DEF(arg) BUFFERI_DEF2 arg
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define BUFFERI_DEF_P1(arg) BUFFERI_DEF_P2 arg
 
-#define BUFFERI_DEF2(name, type, m_size, policy, oplist, buffer_t)      \
+/* Validate the value oplist before going further */
+#define BUFFERI_DEF_P2(name, type, m_size, policy, oplist, buffer_t)    \
+  M_IF_OPLIST(oplist)(BUFFERI_DEF_P3, BUFFERI_DEF_FAILURE)(name, type, m_size, policy, oplist, buffer_t)
+
+/* Stop processing with a compilation failure */
+#define BUFFERI_DEF_FAILURE(name, type, m_size, policy, oplist, buffer_t) \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(BUFFER_DEF): the given argument is not a valid oplist: " M_AS_STR(oplist))
+
+#define BUFFERI_DEF_P3(name, type, m_size, policy, oplist, buffer_t)    \
                                                                         \
   typedef struct M_C(name, _s) {					\
-    m_mutex_t mutexPush;                                                \
-    m_mutex_t mutexPop;                                                 \
-    m_cond_t there_is_data;                                             \
-    m_cond_t there_is_room_for_data;                                    \
-    BUFFERI_IF_CTE_SIZE(m_size)( ,size_t size;)                         \
-    size_t idx_prod, idx_cons, overwrite;			        \
+    m_mutex_t mutexPush;    /* MUTEX used for pushing elements */       \
+    size_t    idx_prod;     /* Index of the production threads  */      \
+    size_t    overwrite;    /* Number of overwritten values */          \
+    m_cond_t there_is_data; /* condition raised when there is data */   \
+    m_cond_t there_is_room_for_data; /* Cond. raised when there is room */ \
+    m_mutex_t mutexPop;     /* MUTEX used for popping elements */       \
+    size_t    idx_cons;     /* Index of the consumption threads */      \
+    BUFFERI_IF_CTE_SIZE(m_size)( ,size_t size;) /* Size of the buffer */ \
+    /* number[0] := Number of elements in the buffer */                 \
+    /* number[1] := [OPTION] Number of elements being deferred in the buffer */ \
     atomic_ulong number[1 + BUFFERI_POLICY_P(policy, BUFFER_DEFERRED_POP)]; \
+    /* If fixed size, array of elements, otherwise pointer to element */ \
     BUFFERI_IF_CTE_SIZE(m_size)(type data[m_size], type *data);         \
   } buffer_t[1];                                                        \
                                                                         \
+  typedef struct M_C(name, _s) *M_C(name, _ptr);                        \
+  typedef const struct M_C(name, _s) *M_C(name, _srcptr);               \
+  typedef union { M_C(name, _srcptr) cptr; M_C(name, _ptr) ptr; } M_C(name, _uptr); \
+  typedef type M_C(name, _type_t);                                      \
+                                                                        \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                      \
+                                                                        \
 static inline void                                                      \
 M_C(name, _init)(buffer_t v, size_t size)                               \
 {                                                                       \
@@ -124,7 +155,7 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
   } else                                                                \
     assert(BUFFERI_POLICY_P((policy), BUFFER_UNBLOCKING));              \
   BUFFERI_IF_CTE_SIZE(m_size)( ,                                        \
-    v->data = M_GET_REALLOC oplist (type, NULL, BUFFERI_SIZE(m_size));  \
+    v->data = M_CALL_REALLOC(oplist, type, NULL, BUFFERI_SIZE(m_size)); \
     if (v->data == NULL) {                                              \
       M_MEMORY_FULL (BUFFERI_SIZE(m_size)*sizeof(type));                \
       return;                                                           \
@@ -132,33 +163,41 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
   )                                                                     \
   if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {         \
     for(size_t i = 0; i < size; i++) {					\
-      M_GET_INIT oplist(v->data[i]);                                    \
+      M_CALL_INIT(oplist, v->data[i]);                                  \
     }									\
   }                                                                     \
   BUFFERI_CONTRACT(v,m_size);						\
 }									\
                                                                         \
+ BUFFERI_IF_CTE_SIZE(m_size)(                                           \
+ static inline void                                                     \
+ M_C(name, _int_init)(buffer_t v)                                       \
+ {                                                                      \
+   M_C(name, _init)(v, m_size);                                         \
+ }                                                                      \
+ , )                                                                    \
+                                                                        \
  static inline void                                                     \
  M_C(name, _int_clear_obj)(buffer_t v)					\
  {                                                                      \
    BUFFERI_CONTRACT(v,m_size);						\
    if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {        \
      for(size_t i = 0; i < BUFFERI_SIZE(m_size); i++) {			\
-       M_GET_CLEAR oplist(v->data[i]);                                  \
+       M_CALL_CLEAR(oplist, v->data[i]);                                \
      }									\
    } else {                                                             \
      size_t i = BUFFERI_POLICY_P((policy), BUFFER_STACK) ? 0 : v->idx_cons; \
      while (i != v->idx_prod) {                                         \
-       M_GET_CLEAR oplist(v->data[i]);                                  \
+       M_CALL_CLEAR(oplist, v->data[i]);                                \
        i++;                                                             \
        if (!BUFFERI_POLICY_P((policy), BUFFER_STACK) && i >= BUFFERI_SIZE(m_size)) \
          i = 0;                                                         \
      }                                                                  \
    }                                                                    \
    v->idx_prod = v->idx_cons = 0;                                       \
-   atomic_store (&v->number[0], 0UL);                                   \
+   atomic_store_explicit (&v->number[0], 0UL, memory_order_relaxed);	\
    if (BUFFERI_POLICY_P(policy, BUFFER_DEFERRED_POP))                   \
-     atomic_store(&v->number[1], 0UL);                                  \
+     atomic_store_explicit(&v->number[1], 0UL, memory_order_relaxed);	\
    BUFFERI_CONTRACT(v,m_size);						\
  }                                                                      \
  									\
@@ -168,7 +207,7 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
    BUFFERI_CONTRACT(v,m_size);						\
    M_C(name, _int_clear_obj)(v);					\
    BUFFERI_IF_CTE_SIZE(m_size)( ,                                       \
-     M_GET_FREE oplist (v->data);                                       \
+     M_CALL_FREE(oplist, v->data);                                      \
      v->data = NULL;                                                    \
    )                                                                    \
    v->overwrite = 0;                                                    \
@@ -192,9 +231,9 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
    if (BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE))		\
      M_C(name, _int_clear_obj)(v);					\
    v->idx_prod = v->idx_cons = 0;                                       \
-   atomic_store (&v->number[0], 0UL);                                   \
+   atomic_store_explicit (&v->number[0], 0UL, memory_order_relaxed);	\
    if (BUFFERI_POLICY_P(policy, BUFFER_DEFERRED_POP))                   \
-     atomic_store(&v->number[1], 0UL);                                  \
+     atomic_store_explicit(&v->number[1], 0UL, memory_order_relaxed);	\
    if (!BUFFERI_POLICY_P((policy), BUFFER_THREAD_UNSAFE)) {             \
      m_cond_broadcast(v->there_is_room_for_data);                       \
      m_mutex_unlock(v->mutexPop);                                       \
@@ -203,6 +242,120 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
    BUFFERI_CONTRACT(v,m_size);						\
  }                                                                      \
  									\
+ static inline void                                                     \
+ M_C(name, _init_set)(buffer_t dest, const buffer_t src)                \
+ {                                                                      \
+   /* unconst 'src', so that we can lock it (semantically it is const) */ \
+   M_C(name, _uptr) vu;                                                 \
+   vu.cptr = src;                                                       \
+   M_C(name, _ptr) v = vu.ptr;                                          \
+   assert (dest != v);                                                  \
+   BUFFERI_CONTRACT(v,m_size);                                          \
+   M_C(name, _init)(dest, BUFFERI_SIZE(m_size));                        \
+   if (!BUFFERI_POLICY_P((policy), BUFFER_THREAD_UNSAFE)) {             \
+     m_mutex_lock(v->mutexPush);                                        \
+     m_mutex_lock(v->mutexPop);                                         \
+   }                                                                    \
+                                                                        \
+   BUFFERI_PROTECTED_CONTRACT(v, m_size);				\
+   if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {        \
+     for(size_t i = 0; i < BUFFERI_SIZE(m_size); i++) {			\
+       M_CALL_INIT_SET(oplist, dest->data[i], v->data[i]);              \
+     }									\
+   } else {                                                             \
+     size_t i = BUFFERI_POLICY_P((policy), BUFFER_STACK) ? 0 : v->idx_cons; \
+     while (i != v->idx_prod) {                                         \
+       M_CALL_INIT_SET(oplist, dest->data[i], v->data[i]);              \
+       i++;                                                             \
+       if (!BUFFERI_POLICY_P((policy), BUFFER_STACK) && i >= BUFFERI_SIZE(m_size)) \
+         i = 0;                                                         \
+     }                                                                  \
+   }                                                                    \
+                                                                        \
+   dest->idx_prod = v->idx_prod;                                        \
+   dest->idx_cons = v->idx_cons;                                        \
+   atomic_store_explicit (&dest->number[0], atomic_load(&v->number[0]), memory_order_relaxed); \
+   if (BUFFERI_POLICY_P(policy, BUFFER_DEFERRED_POP))                   \
+     atomic_store_explicit(&dest->number[1], atomic_load(&v->number[1]), memory_order_relaxed); \
+                                                                        \
+   if (!BUFFERI_POLICY_P((policy), BUFFER_THREAD_UNSAFE)) {             \
+     m_mutex_unlock(v->mutexPop);                                       \
+     m_mutex_unlock(v->mutexPush);                                      \
+   }                                                                    \
+   BUFFERI_CONTRACT(v,m_size);                                          \
+   BUFFERI_CONTRACT(dest, m_size);                                      \
+ }                                                                      \
+ 									\
+ static inline void                                                     \
+ M_C(name, _set)(buffer_t dest, const buffer_t src)                     \
+ {                                                                      \
+   /* unconst 'src', so that we can lock it (semantically it is const) */ \
+   M_C(name, _uptr) vu;                                                 \
+   vu.cptr = src;                                                       \
+   M_C(name, _ptr) v = vu.ptr;                                          \
+   BUFFERI_CONTRACT(dest,m_size);                                       \
+   BUFFERI_CONTRACT(v,m_size);                                          \
+                                                                        \
+   if (dest == v) return;                                               \
+   if (!BUFFERI_POLICY_P((policy), BUFFER_THREAD_UNSAFE)) {             \
+     /* Case of deadlock: A := B, B:=C, C:=A (all in //)                \
+        Solution: order the lock by increasing memory */                \
+     if (dest < v) {                                                    \
+       m_mutex_lock(dest->mutexPush);                                   \
+       m_mutex_lock(dest->mutexPop);                                    \
+       m_mutex_lock(v->mutexPush);                                      \
+       m_mutex_lock(v->mutexPop);                                       \
+     } else {                                                           \
+       m_mutex_lock(v->mutexPush);                                      \
+       m_mutex_lock(v->mutexPop);                                       \
+       m_mutex_lock(dest->mutexPush);                                   \
+       m_mutex_lock(dest->mutexPop);                                    \
+     }                                                                  \
+   }                                                                    \
+                                                                        \
+   BUFFERI_PROTECTED_CONTRACT(v, m_size);				\
+   M_C(name, _int_clear_obj)(dest);					\
+                                                                        \
+   if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {        \
+     for(size_t i = 0; i < BUFFERI_SIZE(m_size); i++) {			\
+       M_CALL_INIT_SET(oplist, dest->data[i], v->data[i]);              \
+     }									\
+   } else {                                                             \
+     size_t i = BUFFERI_POLICY_P((policy), BUFFER_STACK) ? 0 : v->idx_cons; \
+     while (i != v->idx_prod) {                                         \
+       M_CALL_INIT_SET(oplist, dest->data[i], v->data[i]);              \
+       i++;                                                             \
+       if (!BUFFERI_POLICY_P((policy), BUFFER_STACK) && i >= BUFFERI_SIZE(m_size)) \
+         i = 0;                                                         \
+     }                                                                  \
+   }                                                                    \
+                                                                        \
+   dest->idx_prod = v->idx_prod;                                        \
+   dest->idx_cons = v->idx_cons;                                        \
+   atomic_store_explicit (&dest->number[0], atomic_load(&v->number[0]), memory_order_relaxed); \
+   if (BUFFERI_POLICY_P(policy, BUFFER_DEFERRED_POP))                   \
+     atomic_store_explicit(&dest->number[1], atomic_load(&v->number[1]), memory_order_relaxed); \
+                                                                        \
+   if (!BUFFERI_POLICY_P((policy), BUFFER_THREAD_UNSAFE)) {             \
+     /* It may be false, but it is not wrong! */                        \
+     m_cond_broadcast(v->there_is_room_for_data);                       \
+     m_cond_broadcast(v->there_is_data);                                \
+     if (dest < v) {                                                    \
+       m_mutex_unlock(v->mutexPop);                                     \
+       m_mutex_unlock(v->mutexPush);                                    \
+       m_mutex_unlock(dest->mutexPop);                                  \
+       m_mutex_unlock(dest->mutexPush);                                 \
+     } else {                                                           \
+       m_mutex_unlock(dest->mutexPop);                                  \
+       m_mutex_unlock(dest->mutexPush);                                 \
+       m_mutex_unlock(v->mutexPop);                                     \
+       m_mutex_unlock(v->mutexPush);                                    \
+     }                                                                  \
+   }                                                                    \
+   BUFFERI_CONTRACT(v,m_size);                                          \
+   BUFFERI_CONTRACT(dest, m_size);                                      \
+ }                                                                      \
+ 									\
  static inline bool                                                     \
  M_C(name, _empty_p)(buffer_t v)					\
  {                                                                      \
@@ -212,23 +365,24 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
       deferred pop has reached 0, not the number of items in the        \
       buffer is 0. */                                                   \
    if (BUFFERI_POLICY_P(policy, BUFFER_DEFERRED_POP))                   \
-     return atomic_load (&v->number[1]) == 0;                           \
+     return atomic_load_explicit (&v->number[1], memory_order_relaxed) == 0; \
    else                                                                 \
-     return atomic_load (&v->number[0]) == 0;                           \
+     return atomic_load_explicit (&v->number[0], memory_order_relaxed) == 0; \
  }                                                                      \
  									\
  static inline bool                                                     \
  M_C(name, _full_p)(buffer_t v)                                         \
  {                                                                      \
    BUFFERI_CONTRACT(v,m_size);						\
-   return atomic_load (&v->number[0]) == BUFFERI_SIZE(m_size);          \
+   return atomic_load_explicit (&v->number[0], memory_order_relaxed)	\
+     == BUFFERI_SIZE(m_size);						\
  }                                                                      \
  									\
  static inline size_t							\
  M_C(name, _size)(buffer_t v)                                           \
  {                                                                      \
    BUFFERI_CONTRACT(v,m_size);						\
-   return atomic_load (&v->number[0]);                                  \
+   return atomic_load_explicit (&v->number[0], memory_order_relaxed);	\
  }                                                                      \
  									\
  static inline bool                                                     \
@@ -261,10 +415,10 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
      /* Compute the index of the last push element */                   \
      idx--;                                                             \
      if (!BUFFERI_POLICY_P((policy), BUFFER_STACK)) {                   \
-       idx = (idx == -1U) ? BUFFERI_SIZE(m_size)-1 : idx;               \
+       idx = idx >= BUFFERI_SIZE(m_size) ? BUFFERI_SIZE(m_size)-1 : idx; \
      }                                                                  \
      /* Update data in the buffer */                                    \
-     M_GET_SET oplist (v->data[idx], data);                             \
+     M_CALL_SET(oplist, v->data[idx], data);                           \
      previousSize = BUFFERI_SIZE(m_size);                               \
                                                                         \
    } else {                                                             \
@@ -272,9 +426,9 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
      /* Add a new item in the buffer */                                 \
      /* PUSH data in the buffer */                                      \
      if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {      \
-       M_GET_SET oplist (v->data[idx], data);                           \
+       M_CALL_SET(oplist, v->data[idx], data);                          \
      } else {                                                           \
-       M_GET_INIT_SET oplist(v->data[idx], data);                       \
+       M_CALL_INIT_SET(oplist, v->data[idx], data);                     \
      }                                                                  \
                                                                         \
      /* Increment production INDEX of the buffer */                     \
@@ -336,7 +490,7 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
    if (!BUFFERI_POLICY_P((policy), BUFFER_STACK)) {                     \
      /* FIFO queue */                                                   \
      if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {	\
-       M_GET_SET oplist (*data, v->data[v->idx_cons]);                  \
+       M_CALL_SET(oplist, *data, v->data[v->idx_cons]);                 \
      } else {                                                           \
        M_DO_INIT_MOVE (oplist, *data, v->data[v->idx_cons]);            \
      }                                                                  \
@@ -345,7 +499,7 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
      /* STACK queue */                                                  \
      v->idx_prod --;                                                    \
      if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {      \
-       M_GET_SET oplist (*data, v->data[v->idx_prod]);                  \
+       M_CALL_SET(oplist, *data, v->data[v->idx_prod]);                 \
      } else {                                                           \
        M_DO_INIT_MOVE (oplist, *data, v->data[v->idx_prod]);            \
      }                                                                  \
@@ -435,7 +589,18 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
    * size of queue is always a power of 2
    * no overwriting.
    */
-#define QUEUEI_MPMC_DEF(arg) QUEUEI_MPMC_DEF2 arg
+
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define QUEUEI_MPMC_DEF_P1(arg) QUEUEI_MPMC_DEF_P2 arg
+
+/* Validate the value oplist before going further */
+#define QUEUEI_MPMC_DEF_P2(name, type, policy, oplist, buffer_t)    \
+  M_IF_OPLIST(oplist)(QUEUEI_MPMC_DEF_P3, QUEUEI_MPMC_DEF_FAILURE)(name, type, policy, oplist, buffer_t)
+
+/* Stop processing with a compilation failure */
+#define QUEUEI_MPMC_DEF_FAILURE(name, type, policy, oplist, buffer_t) \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(QUEUE_MPMC_DEF): the given argument is not a valid oplist: " M_AS_STR(oplist))
 
 #ifdef NDEBUG
 # define QUEUEI_MPMC_CONTRACT(v) /* nothing */
@@ -443,57 +608,65 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
 # define QUEUEI_MPMC_CONTRACT(v) do {                                   \
     assert (v != 0);                                                    \
     assert (v->Tab != NULL);                                            \
-    unsigned long long _r = atomic_load(&v->ConsoIdx);                  \
-    unsigned long long _w = atomic_load(&v->ProdIdx);                   \
-    assert (_r <= _w);                                                  \
+    unsigned int _r = atomic_load(&v->ConsoIdx);                        \
+    unsigned int _w = atomic_load(&v->ProdIdx);                         \
     _r = atomic_load(&v->ConsoIdx);                                     \
     assert (_r > _w || _w-_r <= v->size);                               \
     assert (M_POWEROF2_P(v->size));                                     \
   } while (0)
 #endif
 
-#define QUEUEI_MPMC_DEF2(name, type, policy, oplist, buffer_t)		\
+#define QUEUEI_MPMC_DEF_P3(name, type, policy, oplist, buffer_t)        \
 									\
   /* The sequence number of an element will be equal to either		\
      - 2* the index of the production which creates it,			\
      - 1 + 2* the index of the consumption which consummes it		\
+     In case of overflow, as there is no order comparison but only      \
+     equal comparison, there is no special issue.                       \
+     Each element is put in a separate cache line to avoid false        \
+     sharing.                                                           \
   */									\
   typedef struct M_C(name, _el_s) {					\
-    atomic_ullong  seq;	/* Can only increase. */			\
+    atomic_uint  seq;	/* Can only increase until overflow */          \
     type         x;							\
-    char align[M_ALIGN_FOR_CACHELINE_EXCLUSION > sizeof(atomic_ullong)+sizeof(type) ? M_ALIGN_FOR_CACHELINE_EXCLUSION - sizeof(atomic_ullong)-sizeof(type) : 1]; \
+    M_CACHELINE_ALIGN(align, atomic_uint, type);                        \
   } M_C(name, _el_t);							\
 									\
+  /* If there is only one producer and one consummer, then they won't   \
+     typically use the same cache line, increasing performance. */      \
   typedef struct M_C(name, _s) {					\
-    atomic_ullong ProdIdx; /* Can only increase */			\
-    char align1[M_ALIGN_FOR_CACHELINE_EXCLUSION];			\
-    atomic_ullong ConsoIdx; /* can only increase */			\
-    char align2[M_ALIGN_FOR_CACHELINE_EXCLUSION];			\
+    atomic_uint ProdIdx; /* Can only increase until overflow */         \
+    M_CACHELINE_ALIGN(align1, atomic_uint);                             \
+    atomic_uint ConsoIdx; /* Can only increase until overflow */        \
+    M_CACHELINE_ALIGN(align2, atomic_uint);                             \
     M_C(name, _el_t) *Tab;                                              \
     unsigned int size;							\
   } buffer_t[1];							\
 									\
   static inline bool              					\
-  M_C(name, _push)(buffer_t table, type x)				\
+  M_C(name, _push)(buffer_t table, type const x)                        \
   {									\
     QUEUEI_MPMC_CONTRACT(table);                                        \
-    unsigned long long idx = atomic_load(&table->ProdIdx);              \
+    unsigned int idx = atomic_load_explicit(&table->ProdIdx,            \
+                                            memory_order_relaxed);      \
     const unsigned int i = idx & (table->size -1);			\
-    const unsigned long long seq = atomic_load(&table->Tab[i].seq);	\
+    const unsigned int seq = atomic_load_explicit(&table->Tab[i].seq,   \
+                                                  memory_order_acquire); \
     if (M_UNLIKELY (2*(idx - table->size) + 1 != seq))	{		\
       /* Buffer full (or unlikely preemption). Can not push */          \
       return false;							\
     }									\
-    if (M_UNLIKELY (!atomic_compare_exchange_strong(&table->ProdIdx, &idx, idx+1))) { \
-      /* Thread has been preemptted by another one. */			\
+    if (M_UNLIKELY (!atomic_compare_exchange_strong_explicit(&table->ProdIdx, \
+	   &idx, idx+1, memory_order_relaxed, memory_order_relaxed))) { \
+      /* Thread has been preempted by another one. */			\
       return false;							\
     }									\
     if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {       \
-      M_GET_SET oplist (table->Tab[i].x, x);				\
+      M_CALL_SET(oplist, table->Tab[i].x, x);				\
     } else {                                                            \
-      M_GET_INIT_SET oplist (table->Tab[i].x, x);                       \
+      M_CALL_INIT_SET(oplist, table->Tab[i].x, x);                      \
     }                                                                   \
-    atomic_store(&table->Tab[i].seq, 2*idx);				\
+    atomic_store_explicit(&table->Tab[i].seq, 2*idx, memory_order_release); \
     QUEUEI_MPMC_CONTRACT(table);                                        \
     return true;                                                        \
   }									\
@@ -503,23 +676,26 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
   {									\
     QUEUEI_MPMC_CONTRACT(table);                                        \
     assert (ptr != NULL);                                               \
-    unsigned long long iC = atomic_load(&table->ConsoIdx);              \
+    unsigned int iC = atomic_load_explicit(&table->ConsoIdx,            \
+                                           memory_order_relaxed);	\
     const unsigned int i = (iC & (table->size -1));			\
-    const unsigned long long seq = atomic_load(&table->Tab[i].seq);	\
+    const unsigned int seq = atomic_load_explicit(&table->Tab[i].seq,   \
+                                                  memory_order_acquire); \
     if (seq != 2 * iC) {						\
       /* Nothing in buffer to consumme (or unlikely preemption) */      \
       return false;							\
     }									\
-    if (M_UNLIKELY (!atomic_compare_exchange_strong(&table->ConsoIdx, &iC, iC+1))) { \
+    if (M_UNLIKELY (!atomic_compare_exchange_strong_explicit(&table->ConsoIdx, \
+	     &iC, iC+1, memory_order_relaxed, memory_order_relaxed))) { \
       /* Thread has been preempted by another one */			\
       return false;							\
     }									\
     if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {       \
-      M_GET_SET oplist (*ptr , table->Tab[i].x);                        \
+      M_CALL_SET(oplist, *ptr, table->Tab[i].x);                        \
     } else {                                                            \
       M_DO_INIT_MOVE (oplist, *ptr, table->Tab[i].x);                   \
     }                                                                   \
-    atomic_store(&table->Tab[i].seq, 2*iC + 1);				\
+    atomic_store_explicit(&table->Tab[i].seq, 2*iC + 1, memory_order_release); \
     QUEUEI_MPMC_CONTRACT(table);                                        \
     return true;                                                        \
   }									\
@@ -529,20 +705,20 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
   {									\
     assert (buffer != NULL);						\
     assert( M_POWEROF2_P(size));					\
-    assert (size <= UINT_MAX);                                          \
+    assert (size < UINT_MAX);                                           \
     assert(((policy) & (BUFFER_STACK|BUFFER_THREAD_UNSAFE|BUFFER_PUSH_OVERWRITE)) == 0); \
-    atomic_init(&buffer->ProdIdx, (unsigned long long) size);           \
-    atomic_init(&buffer->ConsoIdx, (unsigned long long) size);          \
+    atomic_init(&buffer->ProdIdx, (unsigned int) size);                 \
+    atomic_init(&buffer->ConsoIdx, (unsigned int) size);                \
     buffer->size = size;						\
-    buffer->Tab = M_GET_REALLOC oplist (M_C(name, _el_t), NULL, size);	\
+    buffer->Tab = M_CALL_REALLOC(oplist, M_C(name, _el_t), NULL, size); \
     if (buffer->Tab == NULL) {						\
       M_MEMORY_FULL (size*sizeof(M_C(name, _el_t) ));			\
       return;								\
     }									\
     for(unsigned int j = 0; j < size; j++) {                            \
-      atomic_init(&buffer->Tab[j].seq, 2*j+1ULL);                       \
+      atomic_init(&buffer->Tab[j].seq, 2*j+1U);                         \
       if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {     \
-        M_GET_INIT oplist (buffer->Tab[j].x);				\
+        M_CALL_INIT(oplist, buffer->Tab[j].x);				\
       }                                                                 \
     }									\
     QUEUEI_MPMC_CONTRACT(buffer);                                       \
@@ -554,21 +730,21 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
     QUEUEI_MPMC_CONTRACT(buffer);                                       \
     if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {       \
       for(unsigned int j = 0; j < buffer->size; j++) {                  \
-        M_GET_CLEAR oplist (buffer->Tab[j].x);				\
+        M_CALL_CLEAR(oplist, buffer->Tab[j].x);                         \
       }									\
     } else {                                                            \
-      unsigned long long iP = atomic_load(&buffer->ProdIdx);            \
+      unsigned int iP = atomic_load_explicit(&buffer->ProdIdx, memory_order_relaxed); \
       unsigned int i  = iP & (buffer->size -1);                         \
-      unsigned long long iC = atomic_load(&buffer->ConsoIdx);           \
+      unsigned int iC = atomic_load_explicit(&buffer->ConsoIdx, memory_order_relaxed); \
       unsigned int j  = iC & (buffer->size -1);                         \
       while (i != j) {                                                  \
-        M_GET_CLEAR oplist(buffer->Tab[j].x);                           \
+        M_CALL_CLEAR(oplist, buffer->Tab[j].x);                         \
         j++;                                                            \
         if (j >= buffer->size)                                          \
           j = 0;                                                        \
       }                                                                 \
     }                                                                   \
-    M_GET_FREE oplist (buffer->Tab);					\
+    M_CALL_FREE(oplist, buffer->Tab);					\
     buffer->Tab = NULL; /* safer */                                     \
   }									\
 									\
@@ -576,16 +752,28 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
   M_C(name, _size)(buffer_t table)                                      \
   {									\
     QUEUEI_MPMC_CONTRACT(table);                                        \
-    const unsigned long long iC = atomic_load(&table->ConsoIdx);	\
-    const unsigned long long iP = atomic_load(&table->ProdIdx);		\
-    /* We return an approximation as we can't read both iC & iP atomically*/ \
-    /* As we read producer index after consummer index,			\
+    const unsigned int iC = atomic_load_explicit(&table->ConsoIdx, memory_order_relaxed); \
+    const unsigned int iP = atomic_load_explicit(&table->ProdIdx, memory_order_acquire); \
+    /* We return an approximation as we can't read both iC & iP atomically \
+       As we read producer index after consummer index,                 \
        and they are atomic variables without reordering			\
-       producer index is always greater or equal than consummer index */ \
-    assert (iP >= iC);                                                  \
+       producer index is always greater or equal than consumer index    \
+       (or on overflow occurs, in which case as we compute with modulo  \
+       arithmetic, the right result is computed).                       \
+       We may return a result which is greater than the size of the queue \
+       if the function is interrupted a long time between reading iC &  \
+       iP. the function is not protected against it.                    \
+    */                                                                  \
     return iP-iC;							\
   }									\
-									\
+                                                                        \
+  static inline size_t                                                  \
+  M_C(name, _capacity)(buffer_t v)					\
+  {                                                                     \
+    QUEUEI_MPMC_CONTRACT(v);                                            \
+    return v->size;                                                     \
+  }                                                                     \
+                                                                        \
   static inline bool							\
   M_C(name, _empty_p)(buffer_t v)					\
   {									\
@@ -595,12 +783,12 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
   static inline bool							\
   M_C(name, _full_p)(buffer_t v)					\
   {									\
-    return M_C(name, _size)(v) == v->size;                              \
+    return M_C(name, _size)(v) >= v->size;                              \
   }									\
   
 
 
-/* Definition of a a QUEUE for Single Produccer / Single Consummer
+/* Definition of a a QUEUE for Single Producer / Single Consummer
    for high bandwidth scenario:
    * wait-free,
    * quite fast
@@ -609,49 +797,85 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
    * size of queue is always a power of 2
    * no overwriting.
    */
-#define QUEUEI_SPSC_DEF(arg) QUEUEI_SPSC_DEF2 arg
 
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define QUEUEI_SPSC_DEF_P1(arg) QUEUEI_SPSC_DEF_P2 arg
+
+/* Validate the value oplist before going further */
+#define QUEUEI_SPSC_DEF_P2(name, type, policy, oplist, buffer_t)    \
+  M_IF_OPLIST(oplist)(QUEUEI_SPSC_DEF_P3, QUEUEI_SPSC_DEF_FAILURE)(name, type, policy, oplist, buffer_t)
+
+/* Stop processing with a compilation failure */
+#define QUEUEI_SPSC_DEF_FAILURE(name, type, policy, oplist, buffer_t) \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(QUEUE_SPSC_DEF): the given argument is not a valid oplist: " M_AS_STR(oplist))
+
+#ifdef NDEBUG
+#define QUEUEI_SPSC_CONTRACT(table) do { } while (0)
+#else
 #define QUEUEI_SPSC_CONTRACT(table) do {                                \
     assert (table != NULL);                                             \
-    unsigned long long _r = atomic_load(&table->consoIdx);              \
-    unsigned long long _w = atomic_load(&table->prodIdx);               \
-    assert (_r <= _w);                                                  \
+    unsigned int _r = atomic_load(&table->consoIdx);                    \
+    unsigned int _w = atomic_load(&table->prodIdx);                     \
+    /* Due to overflow we don't have assert (_r <= _w); */              \
     _r = atomic_load(&table->consoIdx);                                 \
     assert (_r > _w || _w-_r <= table->size);                           \
     assert (M_POWEROF2_P(table->size));                                 \
   } while (0)
+#endif
 
-#define QUEUEI_SPSC_DEF2(name, type, policy, oplist, buffer_t)          \
+#define QUEUEI_SPSC_DEF_P3(name, type, policy, oplist, buffer_t)        \
                                                                         \
-  /* Not sure if the alignment constraint is needed */                  \
   typedef struct M_C(name, _el_s) {					\
     type         x;							\
-    char align[M_ALIGN_FOR_CACHELINE_EXCLUSION > sizeof(type) ? M_ALIGN_FOR_CACHELINE_EXCLUSION -sizeof(type) : 1]; \
   } M_C(name, _el_t);							\
 									\
   typedef struct M_C(name, _s) {                                        \
-    atomic_ullong consoIdx;                                             \
-    size_t        size;                                                 \
+    atomic_uint  consoIdx; /* Can only increase until overflow */       \
+    unsigned int size;                                                  \
     M_C(name, _el_t) *Tab;                                              \
-    char align[M_ALIGN_FOR_CACHELINE_EXCLUSION > sizeof(atomic_ullong) +sizeof(size_t) +sizeof(void*) ? M_ALIGN_FOR_CACHELINE_EXCLUSION - sizeof(atomic_ullong) -sizeof(size_t)-sizeof(void*): 1]; \
-    atomic_ullong prodIdx;                                              \
+    M_CACHELINE_ALIGN(align, atomic_uint, size_t, M_C(name, _el_t) *);  \
+    atomic_uint prodIdx;  /* Can only increase until overflow */        \
   } buffer_t[1];                                                        \
                                                                         \
   static inline bool              					\
-  M_C(name, _push)(buffer_t table, type x)				\
+  M_C(name, _push)(buffer_t table, type const x)                        \
   {									\
     QUEUEI_SPSC_CONTRACT(table);                                        \
-    unsigned long long r = atomic_load(&table->consoIdx);               \
-    unsigned long long w = atomic_load(&table->prodIdx);                \
-    if (w-r == table->size)                                             \
+    unsigned int r = atomic_load_explicit(&table->consoIdx,             \
+                                          memory_order_relaxed);        \
+    unsigned int w = atomic_load_explicit(&table->prodIdx,              \
+                                          memory_order_acquire);        \
+    if (w-r >= table->size)                                             \
       return false;                                                     \
-    size_t i = w & (table->size -1);                                    \
+    unsigned int i = w & (table->size -1);                              \
     if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {       \
-      M_GET_SET oplist (table->Tab[i].x, x);				\
+      M_CALL_SET(oplist, table->Tab[i].x, x);				\
     } else {                                                            \
-      M_GET_INIT_SET oplist (table->Tab[i].x, x);                       \
+      M_CALL_INIT_SET(oplist, table->Tab[i].x, x);                      \
     }                                                                   \
-    atomic_store(&table->prodIdx, w+1);                                 \
+    atomic_store_explicit(&table->prodIdx, w+1, memory_order_release);	\
+    QUEUEI_SPSC_CONTRACT(table);                                        \
+    return true;                                                        \
+  }                                                                     \
+                                                                        \
+  static inline bool              					\
+  M_C(name, _push_move)(buffer_t table, type x)                         \
+  {									\
+    QUEUEI_SPSC_CONTRACT(table);                                        \
+    unsigned int r = atomic_load_explicit(&table->consoIdx,             \
+                                          memory_order_relaxed);        \
+    unsigned int w = atomic_load_explicit(&table->prodIdx,              \
+                                          memory_order_acquire);        \
+    if (w-r >= table->size)                                             \
+      return false;                                                     \
+    unsigned int i = w & (table->size -1);                              \
+    if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {       \
+      M_DO_MOVE(oplist, table->Tab[i].x, x);				\
+    } else {                                                            \
+      M_DO_INIT_MOVE(oplist, table->Tab[i].x, x);                       \
+    }                                                                   \
+    atomic_store_explicit(&table->prodIdx, w+1, memory_order_release);	\
     QUEUEI_SPSC_CONTRACT(table);                                        \
     return true;                                                        \
   }                                                                     \
@@ -661,30 +885,125 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
   {									\
     QUEUEI_SPSC_CONTRACT(table);                                        \
     assert (ptr != NULL);                                               \
-    unsigned long long w = atomic_load(&table->prodIdx);                \
-    unsigned long long r = atomic_load(&table->consoIdx);               \
+    unsigned int w = atomic_load_explicit(&table->prodIdx,              \
+                                          memory_order_relaxed);	\
+    unsigned int r = atomic_load_explicit(&table->consoIdx,             \
+                                          memory_order_acquire);	\
     if (w-r == 0)                                                       \
       return false;                                                     \
-    size_t i = r & (table->size -1);                                    \
+    unsigned int i = r & (table->size -1);                              \
     if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {       \
-      M_GET_SET oplist (*ptr , table->Tab[i].x);                        \
+      M_CALL_SET(oplist, *ptr , table->Tab[i].x);                       \
     } else {                                                            \
       M_DO_INIT_MOVE (oplist, *ptr, table->Tab[i].x);                   \
     }                                                                   \
-    atomic_store(&table->consoIdx, r+1);                                \
+    atomic_store_explicit(&table->consoIdx, r+1, memory_order_release);	\
     QUEUEI_SPSC_CONTRACT(table);                                        \
     return true;                                                        \
   }                                                                     \
                                                                         \
+  static inline unsigned              					\
+  M_C(name, _push_bulk)(buffer_t table, unsigned n, type const x[])     \
+  {									\
+    QUEUEI_SPSC_CONTRACT(table);                                        \
+    assert (x != NULL);                                                 \
+    assert (n <= table->size);                                          \
+    unsigned int r = atomic_load_explicit(&table->consoIdx,             \
+                                          memory_order_relaxed);        \
+    unsigned int w = atomic_load_explicit(&table->prodIdx,              \
+                                          memory_order_acquire);        \
+    unsigned int max = M_MIN(n, table->size - (w-r) );                  \
+    if (max == 0)                                                       \
+      return 0;                                                         \
+    for(unsigned int k = 0; k < max; k++) {                             \
+      unsigned int i = (w+k) & (table->size -1);                        \
+      if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {     \
+        M_CALL_SET(oplist, table->Tab[i].x, x[k]);                      \
+      } else {                                                          \
+        M_CALL_INIT_SET(oplist, table->Tab[i].x, x[k]);                 \
+      }                                                                 \
+    }                                                                   \
+    atomic_store_explicit(&table->prodIdx, w+max, memory_order_release); \
+    QUEUEI_SPSC_CONTRACT(table);                                        \
+    return max;                                                         \
+  }                                                                     \
+                                                                        \
+  static inline unsigned              					\
+  M_C(name, _pop_bulk)(unsigned int n, type ptr[], buffer_t table)      \
+  {									\
+    QUEUEI_SPSC_CONTRACT(table);                                        \
+    assert (ptr != NULL);                                               \
+    assert (n <= table->size);                                          \
+    unsigned int w = atomic_load_explicit(&table->prodIdx,              \
+                                          memory_order_relaxed);	\
+    unsigned int r = atomic_load_explicit(&table->consoIdx,             \
+                                          memory_order_acquire);	\
+    if (w-r == 0)                                                       \
+      return 0;                                                         \
+    unsigned int max = M_MIN(w-r, n);                                   \
+    for(unsigned int k = 0; k < max; k++) {                             \
+      unsigned int i = (r+k) & (table->size -1);                        \
+      if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {     \
+        M_CALL_SET(oplist, ptr[k], table->Tab[i].x);                    \
+      } else {                                                          \
+        M_DO_INIT_MOVE (oplist, ptr[k], table->Tab[i].x);               \
+      }                                                                 \
+    }                                                                   \
+    atomic_store_explicit(&table->consoIdx, r+max, memory_order_release); \
+    QUEUEI_SPSC_CONTRACT(table);                                        \
+    return max;                                                         \
+  }                                                                     \
+                                                                        \
+  static inline void              					\
+  M_C(name, _push_force)(buffer_t table, type const x)                  \
+  {									\
+    QUEUEI_SPSC_CONTRACT(table);                                        \
+    unsigned int r = atomic_load_explicit(&table->consoIdx,             \
+                                          memory_order_relaxed);        \
+    unsigned int w = atomic_load_explicit(&table->prodIdx,              \
+                                          memory_order_acquire);        \
+    /* If no place in queue, try to skip the last one */                \
+    while (w-r >= table->size) {                                        \
+      bool b = atomic_compare_exchange_strong(&table->consoIdx, &r, r+1); \
+      r += b;                                                           \
+    }                                                                   \
+    unsigned int i = w & (table->size -1);                              \
+    if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {       \
+      M_CALL_SET(oplist, table->Tab[i].x, x);				\
+    } else {                                                            \
+      M_CALL_INIT_SET(oplist, table->Tab[i].x, x);                      \
+    }                                                                   \
+    atomic_store_explicit(&table->prodIdx, w+1, memory_order_release);	\
+    QUEUEI_SPSC_CONTRACT(table);                                        \
+  }                                                                     \
+                                                                        \
   static inline size_t                                                  \
   M_C(name, _size)(buffer_t table)                                      \
   {                                                                     \
     QUEUEI_SPSC_CONTRACT(table);                                        \
-    unsigned long long r = atomic_load(&table->consoIdx);               \
-    unsigned long long w = atomic_load(&table->prodIdx);                \
+    unsigned int r = atomic_load_explicit(&table->consoIdx,             \
+                                          memory_order_relaxed);	\
+    unsigned int w = atomic_load_explicit(&table->prodIdx,              \
+                                          memory_order_acquire);	\
+    /* We return an approximation as we can't read both r & w atomically \
+       As we read producer index after consummer index,                 \
+       and they are atomic variables without reordering			\
+       producer index is always greater or equal than consumer index    \
+       (or on overflow occurs, in which case as we compute with modulo  \
+       arithmetic, the right result is computed).                       \
+       We may return a result which is greater than the size of the queue \
+       if the function is interrupted a long time between reading the   \
+       indexs. The function is not protected against it.                \
+    */                                                                  \
     return w-r;                                                         \
   }                                                                     \
                                                                         \
+ static inline size_t                                                   \
+ M_C(name, _capacity)(buffer_t v)					\
+ {                                                                      \
+   return v->size;                                                      \
+ }                                                                      \
+                                                                        \
   static inline bool							\
   M_C(name, _empty_p)(buffer_t v)					\
   {									\
@@ -694,7 +1013,7 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
   static inline bool							\
   M_C(name, _full_p)(buffer_t v)					\
   {									\
-    return M_C(name, _size)(v) == v->size;                              \
+    return M_C(name, _size)(v) >= v->size;                              \
   }									\
                                                                         \
   static inline void							\
@@ -702,18 +1021,19 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
   {									\
     assert (buffer != NULL);						\
     assert( M_POWEROF2_P(size));					\
+    assert (size < UINT_MAX);                                           \
     assert(((policy) & (BUFFER_STACK|BUFFER_THREAD_UNSAFE|BUFFER_PUSH_OVERWRITE)) == 0); \
-    atomic_init(&buffer->prodIdx, (unsigned long long) size);           \
-    atomic_init(&buffer->consoIdx, (unsigned long long) size);          \
+    atomic_init(&buffer->prodIdx, (unsigned int) size);                 \
+    atomic_init(&buffer->consoIdx, (unsigned int) size);                \
     buffer->size = size;						\
-    buffer->Tab = M_GET_REALLOC oplist (M_C(name, _el_t), NULL, size);	\
+    buffer->Tab = M_CALL_REALLOC(oplist, M_C(name, _el_t), NULL, size); \
     if (buffer->Tab == NULL) {						\
       M_MEMORY_FULL (size*sizeof(M_C(name, _el_t) ));			\
       return;								\
     }									\
     if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {       \
       for(size_t j = 0; j < size; j++) {                                \
-        M_GET_INIT oplist (buffer->Tab[j].x);				\
+        M_CALL_INIT(oplist, buffer->Tab[j].x);				\
       }                                                                 \
     }									\
     QUEUEI_SPSC_CONTRACT(buffer);                                       \
@@ -725,27 +1045,52 @@ M_C(name, _init)(buffer_t v, size_t size)                               \
     QUEUEI_SPSC_CONTRACT(buffer);                                       \
     if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) {       \
       for(unsigned int j = 0; j < buffer->size; j++) {                  \
-        M_GET_CLEAR oplist (buffer->Tab[j].x);				\
+        M_CALL_CLEAR(oplist, buffer->Tab[j].x);                         \
       }									\
     } else {                                                            \
-      unsigned long long iP = atomic_load(&buffer->prodIdx);            \
+      unsigned int iP = atomic_load_explicit(&buffer->prodIdx, memory_order_relaxed); \
       unsigned int i  = iP & (buffer->size -1);                         \
-      unsigned long long iC = atomic_load(&buffer->consoIdx);           \
+      unsigned int iC = atomic_load_explicit(&buffer->consoIdx, memory_order_relaxed); \
       unsigned int j  = iC & (buffer->size -1);                         \
       while (i != j) {                                                  \
-        M_GET_CLEAR oplist(buffer->Tab[j].x);                           \
+        M_CALL_CLEAR(oplist, buffer->Tab[j].x);                         \
         j++;                                                            \
         if (j >= buffer->size)                                          \
           j = 0;                                                        \
       }                                                                 \
     }                                                                   \
-    M_GET_FREE oplist (buffer->Tab);					\
+    M_CALL_FREE(oplist, buffer->Tab);					\
     buffer->Tab = NULL; /* safer */                                     \
   }									\
 									\
 
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define BUFFERI_OPLIST_P1(arg) BUFFERI_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define BUFFERI_OPLIST_P2(name, oplist)					\
+  M_IF_OPLIST(oplist)(BUFFERI_OPLIST_P3, BUFFERI_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define BUFFERI_OPLIST_FAILURE(name, oplist)		\
+  M_LIB_ERROR(ARGUMENT_OF_BUFFER_OPLIST_IS_NOT_AN_OPLIST, name, oplist)
+
+/* OPLIST defininition of a buffer */
+#define BUFFERI_OPLIST_P3(name, oplist)					\
+  (INIT(M_C(name, _int_init))                                           \
+   ,INIT_SET(M_C(name, _init_set))					\
+   ,SET(M_C(name, _set))						\
+   ,CLEAR(M_C(name, _clear))						\
+   ,TYPE(M_C(name,_t))							\
+   ,SUBTYPE(M_C(name, _type_t))						\
+   ,CLEAN(M_C(name,_clean))						\
+   ,PUSH(M_C(name,_push))						\
+   ,POP(M_C(name,_pop))                                                 \
+   ,OPLIST(oplist)                                                      \
+   ,TEST_EMPTY(M_C(name, _empty_p)),                                    \
+   ,GET_SIZE(M_C(name, _size))                                          \
+   )
 
-// NOTE: SET & INIT_SET are deliberatly missing. TBC if it the right way.
-// NOTE: There is no oplist defined for this container.
 
 #endif

m-c-mempool.h

@@ -0,0 +1,826 @@
+/*
+ * M*LIB - Concurrent memory pool allocator
+ *
+ * Copyright (c) 2017-2020, 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.
+*/
+#ifndef MSTARLIB_CONCURRENT_MEMPOOL_H
+#define MSTARLIB_CONCURRENT_MEMPOOL_H
+
+#include "m-core.h"
+#include "m-atomic.h"
+#include "m-genint.h"
+
+/* Minimum number of nodes per group of nodes */
+#define C_MEMPOOL_MIN_NODE_PER_GROUP 16
+
+#define C_MEMPOOL_DEF(name, type_t)                     \
+  C_MEMPOOL_DEF_SINGLY_LIST(name, type_t)               \
+  C_MEMPOOL_DEF_LF_QUEUE(name, type_t)                  \
+  C_MEMPOOL_DEF_LFMP_THREAD_MEMPOOL(name, type_t)       \
+  C_MEMPOOL_DEF_SYSTEM_ALLOC(name, type_t)              \
+  C_MEMPOOL_DEF_LF_MEMPOOL(name, type_t)
+
+/* Classic Singly List without allocation */
+#define C_MEMPOOL_DEF_SINGLY_LIST(name, type_t)                         \
+                                                                        \
+  typedef struct M_C(name, _slist_node_s) {                             \
+    struct M_C(name, _slist_node_s) *next;                              \
+    type_t               data;                                          \
+  } M_C(name, _slist_node_t);                                           \
+                                                                        \
+  typedef struct M_C(name, _slist_node_s) *M_C(name, _slist_t)[1];      \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _slist_init)(M_C(name, _slist_t) list)                      \
+  {                                                                     \
+    *list = NULL;                                                       \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _slist_push)(M_C(name, _slist_t) list,                      \
+                        M_C(name, _slist_node_t) *node)                 \
+  {                                                                     \
+    node->next = *list;                                                 \
+    *list = node;                                                       \
+  }                                                                     \
+                                                                        \
+  static inline M_C(name, _slist_node_t) *                              \
+  M_C(name, _slist_pop)(M_C(name, _slist_t) list)                       \
+  {                                                                     \
+    assert (*list != NULL);                                             \
+    M_C(name, _slist_node_t) *node = *list;                             \
+    *list = node->next;                                                 \
+    M_IF_DEBUG(node->next = NULL;)                                      \
+    return node;                                                        \
+  }                                                                     \
+                                                                        \
+  static inline bool                                                    \
+  M_C(name, _slist_empty_p)(M_C(name, _slist_t) list)                   \
+  {                                                                     \
+    return *list == NULL;                                               \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _slist_move)(M_C(name, _slist_t) list,                      \
+                         M_C(name, _slist_t) src)                       \
+  {                                                                     \
+    *list = *src;                                                       \
+    *src  = NULL;                                                       \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _slist_clear)(M_C(name, _slist_t) list)                     \
+  {                                                                     \
+    M_C(name, _slist_node_t) *it = *list, *next;                        \
+    while (it) {                                                        \
+      next = it->next;                                                  \
+      M_MEMORY_DEL(it);                                                 \
+      it = next;                                                        \
+    }                                                                   \
+    *list = NULL;                                                       \
+  }                                                                     \
+
+
+/* Lock Free free queue list (not generic one) of lists without allocation
+   Based on Michael & Scott Lock Free Queue List algorithm.
+   Each list is considered empty if there is only one node within.
+   This LF Queue List doesn't try to prevent the ABA problem. It is up to the 
+   caller to avoid recycling the nodes too fast.
+   Each list has its own unique NIL ptr in order to avoid issues when 
+   migrating a node from a Q to another: in the following scenario,
+   - Thread 1 performs a PUSH of N in Q1 with Q1 empty (only node is NA)
+   NA.next is NIL.
+   - Thread 1 is interrupted just before the CAS on NA.next
+   - Thread 2 performs a sucessfull push of NB in Q1. NA.next is set to NB.
+   - Thread 2 performs a sucessfull pop of NA in Q1
+   - Thread 2 performs a sucessfull push of NA in Q2. NA.next is set to NIL.
+   - Thread 1 is restored and will succeed as NA.next is once again NIL.
+   In order to prevent the last CAS to succeed, each queue uses its own NIL pointer.
+   It is a derived problem of the ABA problem.
+ */
+/* TODO: Optimize alignement to reduce memory consumption. NIL object can use [] 
+   to reduce memory consumption too (non compatible with C++ ...) */
+#define C_MEMPOOL_DEF_LF_QUEUE(name, type_t)                            \
+                                                                        \
+  typedef struct M_C(name, _lf_node_s) {                                \
+    M_ATTR_EXTENSION _Atomic(struct M_C(name, _lf_node_s) *) next;      \
+    m_gc_atomic_ticket_t                    cpt;                        \
+    M_C(name, _slist_t)                     list;                       \
+  } M_C(name, _lf_node_t);                                              \
+                                                                        \
+  typedef struct M_C(name, _lflist_s) {                                 \
+    M_ATTR_EXTENSION _Atomic(M_C(name, _lf_node_t) *) head;             \
+    char                       align1[M_ALIGN_FOR_CACHELINE_EXCLUSION]; \
+    M_ATTR_EXTENSION _Atomic(M_C(name, _lf_node_t) *) tail;             \
+    char                       align2[M_ALIGN_FOR_CACHELINE_EXCLUSION]; \
+    M_C(name, _lf_node_t)            nil;                               \
+  } M_C(name, _lflist_t)[1];                                            \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _lflist_init)(M_C(name, _lflist_t) list,                    \
+                          M_C(name, _lf_node_t) *node)                  \
+  {                                                                     \
+    atomic_init(&list->head, node);                                     \
+    atomic_init(&list->tail, node);                                     \
+    atomic_store_explicit(&node->next, &list->nil, memory_order_relaxed); \
+  }                                                                     \
+                                                                        \
+  static inline bool                                                    \
+  M_C(name, _lflist_empty_p)(M_C(name, _lflist_t) list)                 \
+  {                                                                     \
+    return atomic_load(&list->tail) == atomic_load(&list->head);        \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _lflist_push)(M_C(name, _lflist_t) list,                    \
+                          M_C(name, _lf_node_t) *node, m_backoff_t bkoff) \
+  {                                                                     \
+    M_C(name, _lf_node_t) *tail;                                        \
+    M_C(name, _lf_node_t) *next;                                        \
+                                                                        \
+    atomic_store_explicit(&node->next, &list->nil, memory_order_relaxed); \
+    m_backoff_reset(bkoff);                                             \
+    while (true) {                                                      \
+      tail = atomic_load(&list->tail);                                  \
+      next = atomic_load_explicit(&tail->next, memory_order_acquire);   \
+      if (M_UNLIKELY(next != &list->nil)) {                             \
+        /* Tail was not pointing to the last node                       \
+           Try to swing Tail to the next node */                        \
+        atomic_compare_exchange_weak_explicit(&list->tail,              \
+                                              &tail, next,              \
+                                              memory_order_release,     \
+                                              memory_order_relaxed);    \
+      } else {                                                          \
+        /* Try to link node at the end of the linked list */            \
+        if (atomic_compare_exchange_strong_explicit(&tail->next,        \
+                                                    &next, node,        \
+                                                    memory_order_release, \
+                                                    memory_order_relaxed)) \
+          break;                                                        \
+        m_backoff_wait(bkoff);                                          \
+      }                                                                 \
+    }                                                                   \
+    /* Enqueue is done.  Try to swing Tail to the inserted node         \
+       If it fails, someone else will do it or has already did it. */   \
+    atomic_compare_exchange_strong_explicit(&list->tail, &tail, node,   \
+                                            memory_order_acq_rel,       \
+                                            memory_order_relaxed);      \
+  }                                                                     \
+                                                                        \
+  static inline M_C(name, _lf_node_t) *                                 \
+  M_C(name, _lflist_pop)(M_C(name, _lflist_t) list, m_backoff_t bkoff)  \
+  {                                                                     \
+    M_C(name, _lf_node_t) *head;                                        \
+    M_C(name, _lf_node_t) *tail;                                        \
+    M_C(name, _lf_node_t) *next;                                        \
+                                                                        \
+    /* Reinitialize backoff */						\
+    m_backoff_reset(bkoff);                                             \
+    while (true) {                                                      \
+      head = atomic_load(&list->head);                                  \
+      tail = atomic_load(&list->tail);                                  \
+      next = atomic_load(&head->next);                                  \
+      /* Are head, tail, and next consistent?*/                         \
+      if (M_LIKELY(head ==                                              \
+                   atomic_load_explicit(&list->head, memory_order_relaxed))) \
+        {                                                               \
+          /* Is queue empty or Tail falling behind? */                  \
+          if (head == tail) {                                           \
+            /* Is queue empty? */                                       \
+            if (next == &list->nil)                                     \
+              return NULL;                                              \
+            /* Tail is falling behind.  Try to advance it */            \
+            atomic_compare_exchange_strong_explicit(&list->tail, &tail, \
+                                                    next,               \
+                                                    memory_order_release, \
+                                                    memory_order_relaxed); \
+          } else {                                                      \
+            /* Try to swing Head to the next node */                    \
+            if (atomic_compare_exchange_strong_explicit(&list->head,    \
+                                                        &head, next,    \
+                                                        memory_order_release, \
+                                                        memory_order_relaxed)) { \
+              break;                                                    \
+            }                                                           \
+	    /* Failure: perform a random exponential backoff */		\
+            m_backoff_wait(bkoff);                                      \
+          }                                                             \
+        }                                                               \
+    }                                                                   \
+    /* dequeue returns an element that becomes the new dummy element (the new head), \
+       and the former dummy element (the former head) is removed:       \
+       Since we want a link of free list, and we don't care about the content itsef, \
+       provided that the node we return is older than the one we should return, \
+       Therefore, we return the previous dummy head.                    \
+       As such, it is not the original MSqueue algorithm. */            \
+    M_IF_DEBUG(atomic_store(&head->next, (M_C(name, _lf_node_t) *) 0);) \
+   return head;                                                         \
+  }                                                                     \
+                                                                        \
+  /* Dequeue a node if the node is old enough */			\
+  static inline M_C(name, _lf_node_t) *                                 \
+  M_C(name, _lflist_pop_if)(M_C(name, _lflist_t) list,                  \
+                            m_gc_ticket_t age, m_backoff_t bkoff)	\
+  {                                                                     \
+    M_C(name, _lf_node_t) *head;                                        \
+    M_C(name, _lf_node_t) *tail;                                        \
+    M_C(name, _lf_node_t) *next;                                        \
+                                                                        \
+    m_backoff_reset(bkoff);                                             \
+    while (true) {                                                      \
+      head = atomic_load(&list->head);                                  \
+      tail = atomic_load(&list->tail);                                  \
+      next = atomic_load(&head->next);                                  \
+      if (M_LIKELY(head == atomic_load_explicit(&list->head, memory_order_relaxed))) \
+        {                                                               \
+          if (head == tail) {                                           \
+            if (next == &list->nil)                                     \
+              return NULL;                                              \
+            atomic_compare_exchange_strong_explicit(&list->tail, &tail, next, \
+                                                    memory_order_release, \
+                                                    memory_order_relaxed); \
+          } else {                                                      \
+            /* Test if the node is old enought to be popped */          \
+            if (atomic_load_explicit(&next->cpt, memory_order_relaxed) >= age) \
+              return NULL;                                              \
+            /* Try to swing Head to the next node */                    \
+            if (atomic_compare_exchange_strong_explicit(&list->head,    \
+                                                        &head, next,    \
+                                                        memory_order_release, \
+                                                        memory_order_relaxed)) { \
+              break;                                                    \
+            }                                                           \
+            m_backoff_wait(bkoff);                                      \
+          }                                                             \
+        }                                                               \
+    }                                                                   \
+    M_IF_DEBUG(atomic_store(&head->next, (M_C(name, _lf_node_t) *) 0);) \
+   return head;                                                         \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _lflist_clear)(M_C(name, _lflist_t) list)                   \
+  {                                                                     \
+    m_backoff_t bkoff;                                                  \
+    m_backoff_init(bkoff);                                              \
+    while (true) {                                                      \
+      M_C(name, _lf_node_t) *node = M_C(name, _lflist_pop)(list, bkoff); \
+      if (node == NULL) break;                                          \
+      M_C(name, _lf_node_t) *next = atomic_load_explicit(&node->next,   \
+                                                         memory_order_relaxed); \
+      M_C(name, _slist_clear)(node->list);                              \
+      M_MEMORY_DEL(node);                                               \
+      node = next;                                                      \
+    }                                                                   \
+    /* Dummy node to free too */                                        \
+    M_C(name, _lf_node_t) *dummy;                                       \
+    dummy = atomic_load_explicit(&list->head, memory_order_relaxed);    \
+    M_C(name, _slist_clear)(dummy->list);                               \
+    M_MEMORY_DEL(dummy);                                                \
+  }                                                                     \
+
+/* System node allocator: request memory to the system.
+   As such it is a non Lock-Free path. */
+#define C_MEMPOOL_DEF_SYSTEM_ALLOC(name, type_t)                        \
+                                                                        \
+  static inline M_C(name, _lf_node_t) *                                 \
+       M_C(name, _alloc_node)(unsigned int initial)                     \
+  {                                                                     \
+    M_C(name, _lf_node_t) * node;                                       \
+    node = M_MEMORY_ALLOC(M_C(name, _lf_node_t));                       \
+    if (M_UNLIKELY(node == NULL)) {                                     \
+      M_MEMORY_FULL(sizeof(M_C(name, _lf_node_t)));                     \
+      return NULL;                                                      \
+    }                                                                   \
+    atomic_init(&node->next, (M_C(name, _lf_node_t) *) 0);              \
+    atomic_init(&node->cpt, 0UL);                                       \
+    M_C(name, _slist_init)(node->list);                                 \
+    for(unsigned i = 0; i < initial; i++) {                             \
+      M_C(name, _slist_node_t) *n;                                      \
+      n = M_MEMORY_ALLOC(M_C(name, _slist_node_t));                     \
+      if (M_UNLIKELY(n == NULL)) {                                      \
+        M_MEMORY_FULL(sizeof(M_C(name, _lf_node_t)));                   \
+        return NULL;                                                    \
+      }                                                                 \
+      M_C(name, _slist_push)(node->list, n);                            \
+    }                                                                   \
+    return node;                                                        \
+  }                                                                     \
+
+/* Concurrent Memory pool
+   The data structure is the following.
+   Each thread has its own pool of nodes (local) that only it can
+   access (it is a singly list). If there is no longer any node in this
+   pool, it requests a new pool to the lock free queue of pool (group of
+   nodes). If it fails, it requests a new pool to the system allocator
+   (and from there it is no longer lock free).
+   This memory pool can only be lock free if the initial state is 
+   sufficiently dimensionned to avoid calling the system allocator during
+   the normal processing.
+   Then each thread pushs its deleted node into another pool of nodes,
+   where the node is logically deleted (no contain of the node is destroyed
+   at this point and the node can be freely accessed by other threads).
+   Once the thread mempool is put to sleep, the age of the pool of logical 
+   deleted nodes is computed and this pool is move to the Lock Free Queue 
+   List of pools to be reclaimed. Then A Garbage Collector is performed
+   on this Lock Free Queue list to reclaim all pools thare are sufficiently
+   aged (taking into account the grace period of the pool) to be moved back
+   to the Lock Free Queue of the free pools.
+
+   Each pool of nodes can be in the following state:
+   * FREE state if it is present in the Lock Free Queue of free pools.
+   * EMPTY state if it is present in the Lock Free Queue of empty pools
+   which means that the nodes present in it has been USED directly by a thread,
+   * TO_BE_RECLAIMED state if it is present in the Lock Free Queue of TBR pools
+
+   A pool of nodes will go to the following state:
+    FREE --> EMPTY --> TO_BE_RECLAIMED
+     ^                      |
+     +----------------------+
+
+   The ABA problem is taken into account as a node cannot be reused in the 
+   same queue without performing a full cycle of its state. Moreover
+   it can only move from TO_BE_RECLAIMED to FREE if and only if a grace 
+   period is finished (and then we are sure that no thread references any
+   older node).
+
+   Each thread has its own backoff structure (with local pseudo-random
+   generator).
+
+   The grace period is detected through a global age counter (ticket)
+   that is incremented each time a thread is awaken / sleep.
+   Each thread has its own age that is set to the global ticket on sleep/awaken.
+   The age of the pool to be reclaimed is also set to this global age counter.
+
+   To ensure that the grace period is finished, it tests if all threads
+   are younger than the age of the pool to be reclaimed.
+
+   From a performance point of view, this puts a bottleneck on the global
+   age counter that is shared and incremented by all threads. However,
+   the sleep/awaken operations are much less frequent than other operations.
+   Thus, it shall not have a huge impact on the performance if the user
+   code is intelligent with the sleep/awaken operations.
+
+   As such it won't support more than ULONG_MAX sleep for all threads.
+*/
+#define C_MEMPOOL_DEF_LFMP_THREAD_MEMPOOL(name, type_t)                 \
+                                                                        \
+  typedef struct M_C(name, _lfmp_thread_s) {                            \
+    M_C(name, _slist_t)  free;                                          \
+    M_C(name, _slist_t)  to_be_reclaimed;                               \
+    M_CACHELINE_ALIGN(align1, M_C(name, _slist_t), M_C(name, _slist_t)); \
+  } M_C(name, _lfmp_thread_t);                                          \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _lfmp_thread_init)(M_C(name, _lfmp_thread_t) *t)            \
+  {                                                                     \
+    M_C(name, _slist_init)(t->free);                                    \
+    M_C(name, _slist_init)(t->to_be_reclaimed);                         \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _lfmp_thread_clear)(M_C(name, _lfmp_thread_t) *t)           \
+  {                                                                     \
+    assert(M_C(name, _slist_empty_p)(t->to_be_reclaimed));              \
+    M_C(name, _slist_clear)(t->free);                                   \
+    M_C(name, _slist_clear)(t->to_be_reclaimed);                        \
+  }                                                                     \
+
+/* NOTE: once a node is deleted, its data are kept readable until the future GC */
+#define C_MEMPOOL_DEF_LF_MEMPOOL(name, type_t)                          \
+                                                                        \
+  typedef struct M_C(name, _s) {                                        \
+    unsigned                  initial;                                  \
+    M_C(name, _lfmp_thread_t) *thread_data;                             \
+    M_C(name, _lflist_t)      free;                                     \
+    M_C(name, _lflist_t)      to_be_reclaimed;                          \
+    M_C(name, _lflist_t)      empty;                                    \
+    m_gc_mempool_list_t       mempool_node;                             \
+    struct m_gc_s            *gc_mem;                                   \
+  } M_C(name, _t)[1];                                                   \
+                                                                        \
+  /* Garbage collect of the nodes of the mempool on sleep */            \
+  static inline void                                                    \
+  M_C(name, _int_gc_on_sleep)(m_gc_t gc_mem, m_gc_mempool_list_t *data, \
+         m_gc_tid_t id, m_gc_ticket_t ticket, m_gc_ticket_t min_ticket) \
+  {                                                                     \
+    /* Get back the mempool from the node */                            \
+    struct M_C(name, _s) *mempool =                                     \
+      M_TYPE_FROM_FIELD(struct M_C(name, _s), data, m_gc_mempool_list_t, mempool_node); \
+                                                                        \
+    /* Move the local nodes of the mempool to be reclaimed to the thread into the global pool */ \
+    if (!M_C(name, _slist_empty_p)(mempool->thread_data[id].to_be_reclaimed)) { \
+      M_C(name, _lf_node_t) *node;                                      \
+      /* Get a new empty group of nodes */                              \
+      node = M_C(name, _lflist_pop)(mempool->empty, gc_mem->thread_data[id].bkoff); \
+      if (M_UNLIKELY (node == NULL)) {                                  \
+        /* Fail to get an empty group of node.                          \
+           Alloc a new one from the system */                           \
+        node = M_C(name, _alloc_node)(0);                               \
+        assert(node != NULL);                                           \
+      }                                                                 \
+      assert(M_C(name, _slist_empty_p)(node->list));                    \
+      M_C(name, _slist_move)(node->list, mempool->thread_data[id].to_be_reclaimed); \
+      atomic_store_explicit(&node->cpt, ticket, memory_order_relaxed);  \
+      M_C(name, _lflist_push)(mempool->to_be_reclaimed, node, gc_mem->thread_data[id].bkoff); \
+    }                                                                   \
+                                                                        \
+    /* Perform a GC of the freelist of nodes */                         \
+    while (true) {                                                      \
+      M_C(name, _lf_node_t) *node;                                      \
+      node = M_C(name, _lflist_pop_if)(mempool->to_be_reclaimed,        \
+                                       min_ticket, gc_mem->thread_data[id].bkoff); \
+      if (node == NULL) break;                                          \
+      M_C(name, _lflist_push)(mempool->free, node, gc_mem->thread_data[id].bkoff); \
+    }                                                                   \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _init)(M_C(name, _t) mem, m_gc_t gc_mem,                    \
+                   unsigned init_node_count, unsigned init_group_count) \
+  {                                                                     \
+    const unsigned long max_thread =  gc_mem->max_thread;               \
+    /* Initialize the thread data of the mempool */                     \
+    mem->thread_data = M_MEMORY_REALLOC(M_C(name, _lfmp_thread_t), NULL, max_thread); \
+    if (mem->thread_data == NULL) {                                     \
+      M_MEMORY_FULL(max_thread * sizeof(M_C(name, _lfmp_thread_t)));    \
+      return;                                                           \
+    }                                                                   \
+    for(unsigned i = 0; i < max_thread;i++) {                           \
+      M_C(name, _lfmp_thread_init)(&mem->thread_data[i]);               \
+    }                                                                   \
+    /* Preallocate some group of nodes for the mempool */               \
+    mem->initial = M_MAX(C_MEMPOOL_MIN_NODE_PER_GROUP, init_node_count); \
+    M_C(name, _lflist_init)(mem->free, M_C(name, _alloc_node)(init_node_count)); \
+    M_C(name, _lflist_init)(mem->to_be_reclaimed, M_C(name, _alloc_node)(init_node_count)); \
+    M_C(name, _lflist_init)(mem->empty, M_C(name, _alloc_node)(0));     \
+    for(unsigned i = 1; i < init_group_count; i++) {                    \
+      M_C(name, _lflist_push)(mem->free, M_C(name, _alloc_node)(init_node_count), \
+                              gc_mem->thread_data[0].bkoff);            \
+      M_C(name, _lflist_push)(mem->empty, M_C(name, _alloc_node)(0),    \
+                              gc_mem->thread_data[0].bkoff);            \
+    }                                                                   \
+    /* Register the mempool in the GC */                                \
+    mem->mempool_node.gc_on_sleep = M_C(name, _int_gc_on_sleep);        \
+    mem->mempool_node.next = gc_mem->mempool_list;                      \
+    gc_mem->mempool_list = &mem->mempool_node;                          \
+    mem->gc_mem = gc_mem;                                               \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _clear)(M_C(name, _t) mem)                                  \
+  {                                                                     \
+    const unsigned max_thread = mem->gc_mem->max_thread;                \
+    for(unsigned i = 0; i < max_thread;i++) {                           \
+      M_C(name, _lfmp_thread_clear)(&mem->thread_data[i]);              \
+    }                                                                   \
+    M_MEMORY_FREE(mem->thread_data);                                    \
+    mem->thread_data = NULL;                                            \
+    M_C(name, _lflist_clear)(mem->empty);                               \
+    M_C(name, _lflist_clear)(mem->free);                                \
+    assert(M_C(name, _lflist_empty_p)(mem->to_be_reclaimed));           \
+    M_C(name, _lflist_clear)(mem->to_be_reclaimed);                     \
+    /* TODO: Unregister from the GC? */                                 \
+  }                                                                     \
+                                                                        \
+  static inline type_t *                                                \
+  M_C(name, _new)(M_C(name, _t) mem, m_gc_tid_t id)                     \
+  {                                                                     \
+    M_C(name, _slist_node_t) *snode;                                    \
+    M_C(name, _lf_node_t) *node;                                        \
+    while (true) {                                                      \
+      /* Fast & likely path where we access the thread pool of nodes */ \
+      if (M_LIKELY(!M_C(name, _slist_empty_p)(mem->thread_data[id].free))) { \
+        snode = M_C(name, _slist_pop)(mem->thread_data[id].free);       \
+        return &snode->data;                                            \
+      }                                                                 \
+      /* Request a group node to the freelist of groups */              \
+      node = M_C(name, _lflist_pop)(mem->free, mem->gc_mem->thread_data[id].bkoff); \
+      if (M_UNLIKELY (node == NULL)) {                                  \
+        /* Request a new group to the system. Non Lock Free path */     \
+        assert(mem->initial > 0);                                       \
+        node = M_C(name, _alloc_node)(mem->initial);                    \
+        assert(node != NULL);                                           \
+        assert(!M_C(name, _slist_empty_p)(node->list));                 \
+      }                                                                 \
+      M_C(name, _slist_move)(mem->thread_data[id].free, node->list);    \
+      /* Push back the empty group */                                   \
+      assert (M_C(name, _slist_empty_p)(node->list));                   \
+      M_C(name, _lflist_push)(mem->empty, node, mem->gc_mem->thread_data[id].bkoff); \
+    }                                                                   \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _del)(M_C(name, _t) mem, type_t *d, m_gc_tid_t id)          \
+  {                                                                     \
+    M_C(name, _slist_node_t) *snode;                                    \
+    assert( d != NULL);                                                 \
+    snode = M_TYPE_FROM_FIELD(M_C(name, _slist_node_t), d, type_t, data); \
+    M_C(name, _slist_push)(mem->thread_data[id].to_be_reclaimed, snode); \
+  }                                                                     \
+
+
+/***********************************************************************/
+
+/* Define the ID of a thread */
+typedef int m_gc_tid_t;
+
+/* Define the age of a node */
+/* TODO: Compute if sufficient (worst cast ULONG_MAX is 32 bits) */
+typedef unsigned long m_gc_ticket_t;
+typedef atomic_ulong  m_gc_atomic_ticket_t;
+
+/* Define the Linked List of mempools that are registered in the GC */
+struct m_gc_s;
+typedef struct m_gc_mempool_list_s {
+  struct m_gc_mempool_list_s *next;
+  void (*gc_on_sleep)(struct m_gc_s *gc_mem,
+                      struct m_gc_mempool_list_s *data, m_gc_tid_t id,
+                      m_gc_ticket_t ticket, m_gc_ticket_t min_ticket);
+  void *data;
+} m_gc_mempool_list_t;
+
+/* Define the Garbage collector thread data */
+typedef struct m_gc_lfmp_thread_s {
+  m_gc_atomic_ticket_t      ticket;
+  m_backoff_t               bkoff;
+  M_CACHELINE_ALIGN(align1, atomic_ulong, m_backoff_t);
+} m_gc_lfmp_thread_t;
+
+/* Define the Garbage collector coordinator */
+typedef struct m_gc_s {
+  m_gc_atomic_ticket_t      ticket;
+  m_gc_tid_t                max_thread;
+  genint_t                  thread_alloc;
+  m_gc_lfmp_thread_t       *thread_data;
+  m_gc_mempool_list_t      *mempool_list;
+} m_gc_t[1];
+
+static inline void
+m_gc_init(m_gc_t gc_mem, unsigned long max_thread)
+{
+  assert(gc_mem != NULL);
+  assert(max_thread > 0 && max_thread < INT_MAX);
+
+  atomic_init(&gc_mem->ticket, 0UL);
+  genint_init(gc_mem->thread_alloc, max_thread);
+  gc_mem->thread_data = M_MEMORY_REALLOC(m_gc_lfmp_thread_t, NULL, max_thread);
+  if (gc_mem->thread_data == NULL) {
+    M_MEMORY_FULL(max_thread * sizeof(m_gc_lfmp_thread_t));
+    return;
+  }
+  for(unsigned i = 0; i < max_thread;i++) {
+    atomic_init(&gc_mem->thread_data[i].ticket, ULONG_MAX);
+    m_backoff_init(gc_mem->thread_data[i].bkoff);
+  }
+  gc_mem->max_thread   = max_thread;
+  gc_mem->mempool_list = NULL;
+}
+
+static inline void
+m_gc_clear(m_gc_t gc_mem)
+{
+  assert(gc_mem != NULL && gc_mem->max_thread > 0);
+  
+  for(m_gc_tid_t i = 0; i < gc_mem->max_thread;i++) {
+    m_backoff_clear(gc_mem->thread_data[i].bkoff);
+  }
+  M_MEMORY_FREE(gc_mem->thread_data);
+  gc_mem->thread_data = NULL;
+  genint_clear(gc_mem->thread_alloc);
+}
+
+static inline m_gc_tid_t
+m_gc_attach_thread(m_gc_t gc_mem)
+{
+  assert(gc_mem != NULL && gc_mem->max_thread > 0);
+  
+  unsigned id = genint_pop(gc_mem->thread_alloc);
+  return M_ASSIGN_CAST(m_gc_tid_t, id);
+}
+  
+static inline void
+m_gc_detach_thread(m_gc_t gc_mem, m_gc_tid_t id)
+{
+  assert(gc_mem != NULL && gc_mem->max_thread > 0);
+  assert(id >= 0 && id < gc_mem->max_thread);
+  assert(atomic_load(&gc_mem->thread_data[id].ticket) == ULONG_MAX);
+
+  genint_push(gc_mem->thread_alloc, id);
+}
+  
+static inline void
+m_gc_awake(m_gc_t gc_mem, m_gc_tid_t id)
+{
+  assert(gc_mem != NULL && gc_mem->max_thread > 0);
+  assert(id >= 0 && id < gc_mem->max_thread);
+  assert(atomic_load(&gc_mem->thread_data[id].ticket) == ULONG_MAX);
+
+  m_gc_ticket_t t = atomic_fetch_add(&gc_mem->ticket, 1UL) + 1;
+  atomic_store(&gc_mem->thread_data[id].ticket, t);
+}
+  
+static inline m_gc_ticket_t
+m_gc_int_min_ticket(m_gc_t gc_mem)
+{
+  m_gc_ticket_t min = atomic_load(&gc_mem->thread_data[0].ticket);
+  for(m_gc_tid_t i = 1; i < gc_mem->max_thread; i++) {
+    m_gc_ticket_t t = atomic_load(&gc_mem->thread_data[i].ticket);
+    min = M_MIN(t, min);
+  }
+  return min;
+}
+
+static inline void
+m_gc_sleep(m_gc_t gc_mem, m_gc_tid_t id)
+{
+  /* Increase life time of the thread */
+  m_gc_ticket_t t = atomic_fetch_add(&gc_mem->ticket, 1UL);
+  atomic_store(&gc_mem->thread_data[id].ticket, t+1);
+  const m_gc_ticket_t min_ticket = m_gc_int_min_ticket(gc_mem);
+  /* Iterate over all registered mempools */
+  m_gc_mempool_list_t *it = gc_mem->mempool_list;
+
+  while (it) {
+    /* Perform a garbage collect of the mempool */
+    it->gc_on_sleep(gc_mem, it, id, t, min_ticket);
+    /* Next mempool to scan for GC */
+    it = it->next;
+  }
+  /* Sleep the thread */
+  atomic_store(&gc_mem->thread_data[id].ticket, ULONG_MAX);
+}
+
+
+/***********************************************************************/
+/*                                                                     */
+/*                              VLA MEMPOOL                            */
+/*                                                                     */
+/***********************************************************************/
+
+C_MEMPOOL_DEF_SINGLY_LIST(m_vlapool, char)
+C_MEMPOOL_DEF_LF_QUEUE(m_vlapool, char)
+C_MEMPOOL_DEF_SYSTEM_ALLOC(m_vlapool, char)
+
+typedef struct m_vlapool_lfmp_thread_s {
+  m_vlapool_slist_t  to_be_reclaimed;
+  M_CACHELINE_ALIGN(align1, m_vlapool_slist_t);
+} m_vlapool_lfmp_thread_t;
+
+static inline void
+m_vlapool_lfmp_thread_init(m_vlapool_lfmp_thread_t *t)
+{
+  m_vlapool_slist_init(t->to_be_reclaimed);
+}
+
+static inline void
+m_vlapool_lfmp_thread_clear(m_vlapool_lfmp_thread_t *t)
+{
+  assert(m_vlapool_slist_empty_p(t->to_be_reclaimed));
+  m_vlapool_slist_clear(t->to_be_reclaimed);
+}
+
+typedef struct m_vlapool_s {
+  m_vlapool_lflist_t        to_be_reclaimed;
+  m_vlapool_lflist_t        empty;
+  m_vlapool_lfmp_thread_t  *thread_data;
+  m_gc_mempool_list_t       mvla_node;
+  struct m_gc_s            *gc_mem;
+} m_vlapool_t[1];
+
+/* Garbage collect of the nodes of the vla mempool on sleep */
+static inline void
+m_vlapool_int_gc_on_sleep(m_gc_t gc_mem, m_gc_mempool_list_t *data,
+                          m_gc_tid_t id, m_gc_ticket_t ticket, m_gc_ticket_t min_ticket)
+{
+  /* Get back the mempool from the node */
+  struct m_vlapool_s *vlapool =
+    M_TYPE_FROM_FIELD(struct m_vlapool_s, data, m_gc_mempool_list_t, mvla_node);
+
+  /* Move the local nodes of the vlapool to be reclaimed to the thread into the global pool */
+  if (!m_vlapool_slist_empty_p(vlapool->thread_data[id].to_be_reclaimed)) {
+    m_vlapool_lf_node_t *node;
+    /* Get a new empty group of nodes */
+    node = m_vlapool_lflist_pop(vlapool->empty, gc_mem->thread_data[id].bkoff);
+    if (M_UNLIKELY (node == NULL)) {
+      /* Fail to get an empty group of node.
+         Alloc a new one from the system */
+      node = m_vlapool_alloc_node(0);
+      assert(node != NULL);
+    }
+    assert(m_vlapool_slist_empty_p(node->list));
+    m_vlapool_slist_move(node->list, vlapool->thread_data[id].to_be_reclaimed);
+    atomic_store_explicit(&node->cpt, ticket, memory_order_relaxed);
+    m_vlapool_lflist_push(vlapool->to_be_reclaimed, node, gc_mem->thread_data[id].bkoff);
+  }
+
+  /* Perform a GC of the freelist of nodes */
+  while (true) {
+    m_vlapool_lf_node_t *node;
+    node = m_vlapool_lflist_pop_if(vlapool->to_be_reclaimed,
+                                   min_ticket, gc_mem->thread_data[id].bkoff);
+    if (node == NULL) break;
+    // No reuse of VLA nodes. Free physically the node back to the system
+    m_vlapool_slist_clear(node->list);
+    // Add back the empty group of nodes
+    m_vlapool_slist_init(node->list);
+    m_vlapool_lflist_push(vlapool->empty, node, gc_mem->thread_data[id].bkoff);
+  }
+}
+
+static inline void
+m_vlapool_init(m_vlapool_t mem, m_gc_t gc_mem)
+{
+  const unsigned long max_thread =  gc_mem->max_thread;
+
+  /* Initialize the thread data of the vlapool */
+  mem->thread_data = M_MEMORY_REALLOC(m_vlapool_lfmp_thread_t, NULL, max_thread);
+  if (mem->thread_data == NULL) {
+    M_MEMORY_FULL(max_thread * sizeof(m_vlapool_lfmp_thread_t));
+    return;
+  }
+  for(unsigned i = 0; i < max_thread;i++) {
+    m_vlapool_lfmp_thread_init(&mem->thread_data[i]);
+  }
+
+  /* Initialize the lists */
+  m_vlapool_lflist_init(mem->to_be_reclaimed, m_vlapool_alloc_node(0));
+  m_vlapool_lflist_init(mem->empty, m_vlapool_alloc_node(0));
+
+  /* Register the mempool in the GC */
+  mem->mvla_node.gc_on_sleep = m_vlapool_int_gc_on_sleep;
+  mem->mvla_node.next = gc_mem->mempool_list;
+  gc_mem->mempool_list = &mem->mvla_node;
+  mem->gc_mem = gc_mem;
+}
+
+static inline void
+m_vlapool_clear(m_vlapool_t mem)
+{
+  const unsigned max_thread = mem->gc_mem->max_thread;
+  for(unsigned i = 0; i < max_thread;i++) {
+    m_vlapool_lfmp_thread_clear(&mem->thread_data[i]);
+  }
+  M_MEMORY_FREE(mem->thread_data);
+  mem->thread_data = NULL;
+  m_vlapool_lflist_clear(mem->empty);
+  assert(m_vlapool_lflist_empty_p(mem->to_be_reclaimed));
+  m_vlapool_lflist_clear(mem->to_be_reclaimed);
+  /* TODO: Unregister from the GC? */
+}
+
+static inline void *
+m_vlapool_new(m_vlapool_t mem, m_gc_tid_t id, size_t size)
+{
+  assert(mem != NULL && mem->gc_mem != NULL);
+  assert(id >= 0 && id < mem->gc_mem->max_thread);
+  assert( atomic_load(&mem->gc_mem->thread_data[id].ticket) != ULONG_MAX);
+
+  // Nothing to do with theses parameters yet
+  (void) mem;
+  (void) id;
+
+  // Ensure the size is big enough to also represent a node
+  size += offsetof(struct m_vlapool_slist_node_s, data);
+
+  // Simply wrap around a system call to get the memory
+  char *ptr = M_MEMORY_REALLOC(char, NULL, size);
+  return (ptr == NULL) ? NULL : M_ASSIGN_CAST(void *, ptr + offsetof(struct m_vlapool_slist_node_s, data));
+}
+
+static inline void
+m_vlapool_del(m_vlapool_t mem, void *d, m_gc_tid_t id)
+{
+  assert(mem != NULL && mem->gc_mem != NULL);
+  assert(id >= 0 && id < mem->gc_mem->max_thread);
+  assert(atomic_load(&mem->gc_mem->thread_data[id].ticket) != ULONG_MAX);
+  assert(d != NULL);
+
+  // Get back the pointer to a struct m_vlapool_slist_node_s.
+  d = M_ASSIGN_CAST(void *, M_ASSIGN_CAST(char *, d) - offsetof(struct m_vlapool_slist_node_s, data));
+  m_vlapool_slist_node_t *snode = M_ASSIGN_CAST(m_vlapool_slist_node_t *, d);
+  // Push the logicaly free memory into the list of the nodes to be reclaimed.
+  m_vlapool_slist_push(mem->thread_data[id].to_be_reclaimed, snode);
+}
+
+
+#endif

m-concurrent.h

@@ -0,0 +1,810 @@
+/*
+ * M*LIB - Basic Protected Concurrent module over container.
+ *
+ * Copyright (c) 2017-2020, 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.
+*/
+#ifndef MSTARLIB_CONCURRENT_H
+#define MSTARLIB_CONCURRENT_H
+
+#include "m-core.h"
+#include "m-mutex.h"
+#include "m-atomic.h"
+
+/* Define a protected concurrent container and its associated functions
+   based on the given container.
+   USAGE: CONCURRENT_DEF(name, type [, oplist_of_the_type]) */
+#define CONCURRENT_DEF(name, ...)                                       \
+  CONCURRENTI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
+               ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name,_t) ), \
+                (name, __VA_ARGS__,                                        M_C(name,_t) )))
+
+
+/* Define the oplist of a protected concurrent container given its name and its oplist.
+   USAGE: CONCURRENT_OPLIST(name[, oplist of the type]) */
+#define CONCURRENT_OPLIST(...)                                          \
+  CONCURRENTI_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                     \
+                     ((__VA_ARGS__, M_DEFAULT_OPLIST),			\
+                      (__VA_ARGS__ )))
+
+
+/* Define a protected concurrent container and its associated functions
+   based on its given container. Operations that perform only read of the container
+   can be done in parallel.
+   USAGE: CONCURRENT_RP_DEF(name, type [, oplist_of_the_type]) */
+#define CONCURRENT_RP_DEF(name, ...)                                    \
+  CONCURRENTI_RP_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                     \
+               ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name,_t) ), \
+                (name, __VA_ARGS__,                                        M_C(name,_t) )))
+
+
+/********************************** INTERNAL ************************************/
+
+/* Deferred evaluation for the oplist definition,
+   so that all arguments are evaluated before further expansion */
+#define CONCURRENTI_OPLIST_P1(arg) CONCURRENTI_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define CONCURRENTI_OPLIST_P2(name, oplist)					\
+  M_IF_OPLIST(oplist)(CONCURRENTI_OPLIST_P3, CONCURRENTI_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define CONCURRENTI_OPLIST_FAILURE(name, oplist)		\
+  M_LIB_ERROR(ARGUMENT_OF_CONCURRENT_OPLIST_IS_NOT_AN_OPLIST, name, oplist)
+
+/* OPLIST definition
+   GET_KEY is not present as its interface is not compatible with a concurrent
+   container (_get returns a pointer to an internal data, data that may be 
+   destroyed by another thread).
+*/
+#define CONCURRENTI_OPLIST_P3(name, oplist)                             \
+  (M_IF_METHOD(INIT, oplist)(INIT(M_C(name, _init)),)                   \
+   ,M_IF_METHOD(INIT_SET, oplist)(INIT_SET(M_C(name, _init_set)),)      \
+   ,M_IF_METHOD(SET, oplist)(SET(M_C(name, _set)),)                     \
+   ,M_IF_METHOD(CLEAR, oplist)(CLEAR(M_C(name, _clear)),)               \
+   ,M_IF_METHOD(INIT_MOVE, oplist)(INIT_MOVE(M_C(name, _init_move)),)   \
+   ,M_IF_METHOD(MOVE, oplist)(MOVE(M_C(name, _move)),)                  \
+   ,M_IF_METHOD(SWAP,oplist)(SWAP(M_C(name, _swap)),)                   \
+   ,TYPE(M_C(name,_t))							\
+   ,SUBTYPE(M_C(name, _type_t))						\
+   ,OPLIST(oplist)                                                      \
+   ,M_IF_METHOD(TEST_EMPTY, oplist)(TEST_EMPTY(M_C(name,_empty_p)),)    \
+   ,M_IF_METHOD(GET_SIZE, oplist)(GET_SIZE(M_C(name,_size)),)           \
+   ,M_IF_METHOD(CLEAN, oplist)(CLEAN(M_C(name,_clean)),)                \
+   ,M_IF_METHOD(KEY_TYPE, oplist)(KEY_TYPE(M_GET_KEY_TYPE oplist),)     \
+   ,M_IF_METHOD(VALUE_TYPE, oplist)(VALUE_TYPE(M_GET_VALUE_TYPE oplist),) \
+   ,M_IF_METHOD(KEY_TYPE, oplist)(KEY_OPLIST(M_GET_KEY_OPLIST oplist),) \
+   ,M_IF_METHOD(VALUE_TYPE, oplist)(VALUE_OPLIST(M_GET_VALUE_OPLIST oplist), ) \
+   ,M_IF_METHOD(SET_KEY, oplist)(SET_KEY(M_C(name, _set_at)),)          \
+   ,M_IF_METHOD(ERASE_KEY, oplist)(ERASE_KEY(M_C(name, _erase)),)       \
+   ,M_IF_METHOD(PUSH, oplist)(PUSH(M_C(name,_push)),)                   \
+   ,M_IF_METHOD(POP, oplist)(POP(M_C(name,_pop)),)                      \
+   ,M_IF_METHOD(PUSH_MOVE, oplist)(PUSH_MOVE(M_C(name,_push_move)),)    \
+   ,M_IF_METHOD(POP_MOVE, oplist)(POP_MOVE(M_C(name,_pop_move)),)       \
+   ,M_IF_METHOD(GET_STR, oplist)(GET_STR(M_C(name, _get_str)),)		\
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(M_C(name, _parse_str)),)   \
+   ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_C(name, _out_str)),)		\
+   ,M_IF_METHOD(IN_STR, oplist)(IN_STR(M_C(name, _in_str)),)		\
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(M_C(name, _out_serial)),) \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(M_C(name, _in_serial)),)   \
+   ,M_IF_METHOD(EQUAL, oplist)(EQUAL(M_C(name, _equal_p)),)		\
+   ,M_IF_METHOD(HASH, oplist)(HASH(M_C(name, _hash)),)			\
+   ,M_IF_METHOD(NEW, oplist)(NEW(M_GET_NEW oplist),)                    \
+   ,M_IF_METHOD(REALLOC, oplist)(REALLOC(M_GET_REALLOC oplist),)        \
+   ,M_IF_METHOD(DEL, oplist)(DEL(M_GET_DEL oplist),)                    \
+   )
+
+/* Internal contract 
+   Nothing notable. Can't check too much without locking the structure itself
+*/
+#define CONCURRENTI_CONTRACT(c) do {            \
+    assert ((c) != NULL);                       \
+  } while (0)
+
+/* Deferred evaluation for the concurrent definition,
+   so that all arguments are evaluated before further expansion */
+#define CONCURRENTI_DEF_P1(arg) CONCURRENTI_DEF_P2 arg
+
+/* Validate the value oplist before going further */
+#define CONCURRENTI_DEF_P2(name, type, oplist, concurrent_t)            \
+  M_IF_OPLIST(oplist)(CONCURRENTI_DEF_P3, CONCURRENTI_DEF_FAILURE)(name, type, oplist, concurrent_t)
+
+/* Stop processing with a compilation failure */
+#define CONCURRENTI_DEF_FAILURE(name, type, oplist, concurrent_t) \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(CONCURRENT_DEF): the given argument is not a valid oplist: " M_AS_STR(oplist))
+
+/* Internal concurrent definition
+   - name: prefix to be used
+   - type: type of the sub container
+   - oplist: oplist of the type of the sub container
+   - concurrent_t: alias for M_C(name, _t) [ type of the container ]
+ */
+#define CONCURRENTI_DEF_P3(name, type, oplist, concurrent_t)            \
+                                                                        \
+  typedef struct M_C(name, _s) {					\
+    struct M_C(name, _s) *self;                                         \
+    m_mutex_t lock;                                                     \
+    m_cond_t  there_is_data; /* condition raised when there is data */  \
+    type      data;                                                     \
+  } concurrent_t[1];                                                    \
+                                                                        \
+  typedef struct M_C(name, _s) *M_C(name, _ptr);                        \
+  typedef const struct M_C(name, _s) *M_C(name, _srcptr);               \
+									\
+  typedef type M_C(name, _type_t);					\
+                                                                        \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                      \
+                                                                        \
+  /* Define the lock strategy (global & shared lock) */                 \
+  static inline void                                                    \
+  M_C(name, _internal_init)(concurrent_t out)                           \
+  {                                                                     \
+    m_mutex_init(out->lock);                                            \
+    m_cond_init(out->there_is_data);                                    \
+    out->self = out;                                                    \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _internal_clear)(concurrent_t out)                          \
+  {                                                                     \
+    assert (out->self == out);                                          \
+    m_mutex_clear(out->lock);                                           \
+    m_cond_clear(out->there_is_data);                                   \
+    out->self = NULL;                                                   \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _read_lock)(const concurrent_t out)                         \
+  {                                                                     \
+    assert (out->self == out);                                          \
+    m_mutex_lock (out->self->lock);                                     \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _read_unlock)(const concurrent_t out)                       \
+  {                                                                     \
+    assert (out->self == out);                                          \
+    m_mutex_unlock (out->self->lock);                                   \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _read_wait)(const concurrent_t out)                         \
+  {                                                                     \
+    assert (out->self == out);                                          \
+    m_cond_wait(out->self->there_is_data, out->self->lock);             \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _write_lock)(concurrent_t out)                              \
+  {                                                                     \
+    m_mutex_lock (out->lock);                                           \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _write_unlock)(concurrent_t out)                            \
+  {                                                                     \
+    m_mutex_unlock (out->lock);                                         \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _write_wait)(const concurrent_t out)                        \
+  {                                                                     \
+    m_cond_wait(out->self->there_is_data, out->self->lock);             \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _write_signal)(concurrent_t out)                            \
+  {                                                                     \
+    m_cond_broadcast(out->there_is_data);                               \
+  }                                                                     \
+                                                                        \
+  CONCURRENTI_DEF_FUNC_P3(name, type, oplist, concurrent_t)
+
+
+/* Internal definition of the functions commons to concurrent and rp-concurrent
+   - name: prefix to be used
+   - type: type of the sub container
+   - oplist: oplist of the type of the sub container
+   - concurrent_t: alias for M_C(name, _t) [ type of the container ]
+*/
+#define CONCURRENTI_DEF_FUNC_P3(name, type, oplist, concurrent_t)       \
+                                                                        \
+  M_IF_METHOD(INIT, oplist)(                                            \
+  static inline void                                                    \
+  M_C(name, _init)(concurrent_t out)                                    \
+  {                                                                     \
+    M_C(name, _internal_init)(out);                                     \
+    M_CALL_INIT(oplist, out->data);                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(INIT_SET, oplist)(                                        \
+  static inline void                                                    \
+  M_C(name, _init_set)(concurrent_t out, concurrent_t const src)        \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(src);                                          \
+    assert (out != src);                                                \
+    M_C(name, _internal_init)(out);                                     \
+    M_C(name, _read_lock)(src);                                         \
+    M_CALL_INIT_SET(oplist, out->data, src->data);                      \
+    M_C(name, _read_unlock)(src);                                       \
+    CONCURRENTI_CONTRACT(out);                                          \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(SET, oplist)(                                             \
+  static inline void                                                    \
+  M_C(name, _set)(concurrent_t out, concurrent_t const src)             \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    if (out == src) return;                                             \
+    if (out < src) {                                                    \
+      M_C(name, _write_lock)(out);                                      \
+      M_C(name, _read_lock)(src);                                       \
+    } else {                                                            \
+      M_C(name, _read_lock)(src);                                       \
+      M_C(name, _write_lock)(out);                                      \
+    }                                                                   \
+    M_CALL_SET(oplist, out->data, src->data);                           \
+    if (out < src) {                                                    \
+      M_C(name, _read_lock)(src);                                       \
+      M_C(name, _write_unlock)(out);                                    \
+    } else {                                                            \
+      M_C(name, _write_unlock)(out);                                    \
+      M_C(name, _read_unlock)(src);                                     \
+    }                                                                   \
+    CONCURRENTI_CONTRACT(out);                                          \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(CLEAR, oplist)(                                           \
+  static inline void                                                    \
+  M_C(name, _clear)(concurrent_t out)                                   \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    /* No need to lock */                                               \
+    M_CALL_CLEAR(oplist, out->data);                                    \
+    M_C(name, _internal_clear)(out);                                    \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(INIT_MOVE, oplist)(                                       \
+  static inline void                                                    \
+  M_C(name, _init_move)(concurrent_t out, concurrent_t src)             \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(src);                                          \
+    assert (out != src);                                                \
+    /* No need to lock 'src' ? */                                       \
+    M_C(name, _internal_init)(out);                                     \
+    M_CALL_INIT_MOVE(oplist, out->data, src->data);                     \
+    M_C(name, _internal_clear)(src);                                    \
+    CONCURRENTI_CONTRACT(out);                                          \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(MOVE, oplist)(                                            \
+  static inline void                                                    \
+  M_C(name, _move)(concurrent_t out, concurrent_t src)                  \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    CONCURRENTI_CONTRACT(src);                                          \
+    /* No need to lock 'src' ? */                                       \
+    M_C(name, _write_lock)(out);                                        \
+    M_CALL_MOVE(oplist, out->data, src->data);                          \
+    M_C(name, _write_unlock)(out);                                      \
+    M_C(name, _internal_clear)(src);                                    \
+    CONCURRENTI_CONTRACT(out);                                          \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(SWAP, oplist)(                                            \
+  static inline void                                                    \
+  M_C(name, _swap)(concurrent_t out, concurrent_t src)                  \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    CONCURRENTI_CONTRACT(src);                                          \
+    if (out < src) {                                                    \
+      M_C(name, _write_lock)(out);                                      \
+      M_C(name, _write_lock)(src);                                      \
+    } else {                                                            \
+      M_C(name, _write_lock)(src);                                      \
+      M_C(name, _write_lock)(out);                                      \
+    }                                                                   \
+    M_CALL_SWAP(oplist, out->data, src->data);                          \
+    if (out < src) {                                                    \
+      M_C(name, _write_unlock)(src);                                    \
+      M_C(name, _write_unlock)(out);                                    \
+    } else {                                                            \
+      M_C(name, _write_unlock)(out);                                    \
+      M_C(name, _write_unlock)(src);                                    \
+    }                                                                   \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(CLEAN, oplist)(                                           \
+  static inline void                                                    \
+  M_C(name, _clean)(concurrent_t out)                                   \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    M_C(name, _write_lock)(out);                                        \
+    M_CALL_CLEAN(oplist, out->data);                                    \
+    M_C(name, _write_unlock)(out);                                      \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(TEST_EMPTY, oplist)(                                      \
+  static inline bool                                                    \
+  M_C(name, _empty_p)(concurrent_t const out)                           \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    M_C(name, _read_lock)(out);                                         \
+    bool b = M_CALL_TEST_EMPTY(oplist, out->data);                      \
+    M_C(name, _read_unlock)(out);                                       \
+    return b;                                                           \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(GET_SIZE, oplist)(                                        \
+  static inline size_t                                                  \
+  M_C(name, _size)(concurrent_t const out)                              \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    M_C(name, _read_lock)(out);                                         \
+    size_t r = M_CALL_GET_SIZE(oplist, out->data);                      \
+    M_C(name, _read_unlock)(out);                                       \
+    return r;                                                           \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(SET_KEY, oplist)(                                         \
+  static inline void                                                    \
+  M_C(name, _set_at)(concurrent_t out, M_GET_KEY_TYPE oplist const key, M_GET_VALUE_TYPE oplist const data) \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    M_C(name, _write_lock)(out);                                        \
+    M_CALL_SET_KEY(oplist, out->data, key, data);                       \
+    M_C(name, _write_signal)(out);                                      \
+    M_C(name, _write_unlock)(out);                                      \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(GET_KEY, oplist)(                                         \
+  static inline bool                                                    \
+  M_C(name, _get_copy)(M_GET_VALUE_TYPE oplist *out_data, const concurrent_t out, M_GET_KEY_TYPE oplist const key) \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    assert (out_data != NULL);                                          \
+    M_C(name, _read_lock)(out);                                         \
+    M_GET_VALUE_TYPE oplist *p = M_CALL_GET_KEY(oplist, out->data, key); \
+    if (p != NULL) {                                                    \
+      M_CALL_SET(M_GET_VALUE_OPLIST oplist, *out_data, *p);             \
+    }                                                                   \
+    M_C(name, _read_unlock)(out);                                       \
+    return p != NULL;                                                   \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(GET_SET_KEY, oplist)(                                     \
+  static inline void                                                    \
+  M_C(name, _get_at_copy)(M_GET_VALUE_TYPE oplist *out_data, concurrent_t out, M_GET_KEY_TYPE oplist const key) \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    assert (out_data != NULL);                                          \
+    M_C(name, _write_lock)(out);                                        \
+    M_GET_VALUE_TYPE oplist *p = M_CALL_GET_SET_KEY(oplist, out->data, key); \
+    assert (p != NULL);                                                 \
+    M_CALL_SET(M_GET_VALUE_OPLIST oplist, *out_data, *p);               \
+    M_C(name, _write_unlock)(out);                                      \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(ERASE_KEY, oplist)(                                       \
+  static inline bool                                                    \
+  M_C(name, _erase)(concurrent_t out, M_GET_KEY_TYPE oplist const key)  \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    M_C(name, _write_lock)(out);                                        \
+    bool b = M_CALL_ERASE_KEY(oplist, out->data, key);                  \
+    M_C(name, _write_unlock)(out);                                      \
+    return b;                                                           \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(PUSH, oplist)(                                            \
+  static inline void                                                    \
+  M_C(name, _push)(concurrent_t out, M_GET_SUBTYPE oplist const data)   \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    M_C(name, _write_lock)(out);                                        \
+    M_CALL_PUSH(oplist, out->data, data);                               \
+    M_C(name, _write_signal)(out);                                      \
+    M_C(name, _write_unlock)(out);                                      \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(POP, oplist)(                                             \
+  static inline void                                                    \
+  M_C(name, _pop)(M_GET_SUBTYPE oplist *p, concurrent_t out)            \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    M_C(name, _write_lock)(out);                                        \
+    M_CALL_POP(oplist, p, out->data);                                   \
+    M_C(name, _write_unlock)(out);                                      \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(PUSH_MOVE, oplist)(                                       \
+  static inline void                                                    \
+  M_C(name, _push_move)(concurrent_t out, M_GET_SUBTYPE oplist *data)   \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    M_C(name, _write_lock)(out);                                        \
+    M_CALL_PUSH_MOVE(oplist, out->data, data);                          \
+    M_C(name, _write_signal)(out);                                      \
+    M_C(name, _write_unlock)(out);                                      \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(POP_MOVE, oplist)(                                        \
+  static inline void                                                    \
+  M_C(name, _pop_move)(M_GET_SUBTYPE oplist *p, concurrent_t out)       \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    M_C(name, _write_lock)(out);                                        \
+    M_CALL_POP_MOVE(oplist, p, out->data);                              \
+    M_C(name, _write_unlock)(out);                                      \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(GET_STR, oplist)(                                         \
+  static inline void                                                    \
+  M_C(name, _get_str)(string_t str, concurrent_t const out, bool a)     \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    M_C(name, _read_lock)(out);                                         \
+    M_CALL_GET_STR(oplist, str, out->data, a);                          \
+    M_C(name, _read_unlock)(out);                                       \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(OUT_STR, oplist)(                                         \
+  static inline void                                                    \
+  M_C(name, _out_str)(FILE *f, concurrent_t const out)                  \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    M_C(name, _read_lock)(out);                                         \
+    M_CALL_OUT_STR(oplist, f, out->data);                               \
+    M_C(name, _read_unlock)(out);                                       \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(PARSE_STR, oplist)(                                       \
+  static inline bool                                                    \
+  M_C(name, _parse_str)(concurrent_t out, const char str[], const char **e) \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    M_C(name, _write_lock)(out);                                        \
+    bool b = M_CALL_PARSE_STR(oplist, out->data, str, e);               \
+    M_C(name, _write_signal)(out);                                      \
+    M_C(name, _write_unlock)(out);                                      \
+    return b;                                                           \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(IN_STR, oplist)(                                          \
+  static inline bool                                                    \
+  M_C(name, _in_str)(concurrent_t out, FILE *f)                         \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    M_C(name, _write_lock)(out);                                        \
+    bool b = M_CALL_IN_STR(oplist, out->data, f);                       \
+    M_C(name, _write_signal)(out);                                      \
+    M_C(name, _write_unlock)(out);                                      \
+    return b;                                                           \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(OUT_SERIAL, oplist)(                                      \
+  static inline m_serial_return_code_t                                  \
+  M_C(name, _out_serial)(m_serial_write_t f, concurrent_t const out)    \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    M_C(name, _read_lock)(out);                                         \
+    m_serial_return_code_t r = M_CALL_OUT_SERIAL(oplist, f, out->data); \
+    M_C(name, _read_unlock)(out);                                       \
+    return r;                                                         \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(IN_SERIAL, oplist)(                                       \
+  static inline m_serial_return_code_t                                  \
+  M_C(name, _in_serial)(concurrent_t out, m_serial_read_t f)            \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    M_C(name, _write_lock)(out);                                        \
+    m_serial_return_code_t r = M_CALL_IN_SERIAL(oplist, out->data, f);  \
+    M_C(name, _write_signal)(out);                                      \
+    M_C(name, _write_unlock)(out);                                      \
+    return r;                                                           \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(EQUAL, oplist)(                                           \
+  static inline bool                                                    \
+  M_C(name, _equal_p)(concurrent_t const out1, concurrent_t const out2) \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out1);                                         \
+    CONCURRENTI_CONTRACT(out2);                                         \
+    if (out1 == out2) return true;                                      \
+    if (out1 < out2) {                                                  \
+      M_C(name, _read_lock)(out1);                                      \
+      M_C(name, _read_lock)(out2);                                      \
+    } else {                                                            \
+      M_C(name, _read_lock)(out2);                                      \
+      M_C(name, _read_lock)(out1);                                      \
+    }                                                                   \
+    bool b = M_CALL_EQUAL(oplist, out1->data, out2->data);              \
+    if (out1 < out2) {                                                  \
+      M_C(name, _read_unlock)(out2);                                    \
+      M_C(name, _read_unlock)(out1);                                    \
+    } else {                                                            \
+      M_C(name, _read_unlock)(out1);                                    \
+      M_C(name, _read_unlock)(out2);                                    \
+    }                                                                   \
+    return b;                                                           \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(GET_KEY, oplist)(                                         \
+  static inline bool                                                    \
+  M_C(name, _get_blocking)(M_GET_VALUE_TYPE oplist *out_data, const concurrent_t out, M_GET_KEY_TYPE oplist const key, bool blocking) \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    assert (out_data != NULL);                                          \
+    bool ret = false;                                                   \
+    M_C(name, _read_lock)(out);                                         \
+    while (true) {                                                      \
+      M_GET_VALUE_TYPE oplist *p = M_CALL_GET_KEY(oplist, out->data, key); \
+      if (p != NULL) {                                                  \
+        M_CALL_SET(M_GET_VALUE_OPLIST oplist, *out_data, *p);           \
+        ret = true;                                                     \
+        break;                                                          \
+      }                                                                 \
+      if (blocking == false) break;                                     \
+      M_C(name, _read_wait)(out);                                       \
+    }                                                                   \
+    M_C(name, _read_unlock)(out);                                       \
+    return ret;                                                         \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD2(POP, TEST_EMPTY, oplist)(                                \
+  static inline bool                                                    \
+  M_C(name, _pop_blocking)(M_GET_SUBTYPE oplist *p, concurrent_t out, bool blocking) \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    assert (p != NULL);                                                 \
+    bool ret = false;                                                   \
+    M_C(name, _write_lock)(out);                                        \
+    while (true) {                                                      \
+      if (!M_CALL_TEST_EMPTY(oplist, out->data)) {                      \
+        M_CALL_POP(oplist, p, out->data);                               \
+        ret = true;                                                     \
+        break;                                                          \
+      }                                                                 \
+      if (blocking == false) break;                                     \
+      M_C(name, _write_wait)(out);                                      \
+    }                                                                   \
+    M_C(name, _write_unlock)(out);                                      \
+    return ret;                                                         \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD2(POP_MOVE, TEST_EMPTY, oplist)(                           \
+  static inline bool                                                    \
+  M_C(name, _pop_move_blocking)(M_GET_SUBTYPE oplist *p, concurrent_t out, bool blocking) \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    assert (p != NULL);                                                 \
+    bool ret = false;                                                   \
+    M_C(name, _write_lock)(out);                                        \
+    while (true) {                                                      \
+      if (!M_CALL_TEST_EMPTY(oplist, out->data)) {                      \
+        M_CALL_POP_MOVE(oplist, p, out->data);                          \
+        ret = true;                                                     \
+        break;                                                          \
+      }                                                                 \
+      if (blocking == false) break;                                     \
+      M_C(name, _write_wait)(out);                                      \
+    }                                                                   \
+    M_C(name, _write_unlock)(out);                                      \
+    return ret;                                                         \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
+  M_IF_METHOD(HASH, oplist)(                                            \
+  static inline size_t                                                  \
+  M_C(name, _hash)(concurrent_t const out)                              \
+  {                                                                     \
+    CONCURRENTI_CONTRACT(out);                                          \
+    M_C(name, _read_lock)(out);                                         \
+    size_t h = M_CALL_HASH(oplist, out->data);                          \
+    M_C(name, _read_unlock)(out);                                       \
+    return h;                                                           \
+  }                                                                     \
+  ,)                                                                    \
+
+
+
+/* Deferred evaluation for the RP concurrent definition,
+   so that all arguments are evaluated before further expansion */
+#define CONCURRENTI_RP_DEF_P1(arg) CONCURRENTI_RP_DEF_P2 arg
+
+/* Validate the value oplist before going further */
+#define CONCURRENTI_RP_DEF_P2(name, type, oplist, concurrent_t)            \
+  M_IF_OPLIST(oplist)(CONCURRENTI_RP_DEF_P3, CONCURRENTI_RP_DEF_FAILURE)(name, type, oplist, concurrent_t)
+
+/* Stop processing with a compilation failure */
+#define CONCURRENTI_RP_DEF_FAILURE(name, type, oplist, concurrent_t) \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(CONCURRENT_RP_DEF): the given argument is not a valid oplist: " M_AS_STR(oplist))
+
+/* Internal RP concurrent definition
+   - name: prefix to be used
+   - type: type of the sub container
+   - oplist: oplist of the type of the sub container
+   - concurrent_t: alias for M_C(name, _t) [ type of the container ]
+ */
+#define CONCURRENTI_RP_DEF_P3(name, type, oplist, concurrent_t)         \
+                                                                        \
+  typedef struct M_C(name, _s) {					\
+    struct M_C(name, _s) *self;                                         \
+    m_mutex_t lock;                                                     \
+    m_cond_t  rw_done;                                                  \
+    size_t    read_count;                                               \
+    bool      writer_waiting;                                           \
+    m_cond_t  there_is_data; /* condition raised when there is data */  \
+    type      data;                                                     \
+  } concurrent_t[1];                                                    \
+                                                                        \
+  typedef struct M_C(name, _s) *M_C(name, _ptr);                        \
+  typedef const struct M_C(name, _s) *M_C(name, _srcptr);               \
+									\
+  typedef type M_C(name, _type_t);					\
+                                                                        \
+  /* Define the lock strategy (multi lock) */                           \
+  static inline void                                                    \
+  M_C(name, _internal_init)(concurrent_t out)                           \
+  {                                                                     \
+    m_mutex_init(out->lock);                                            \
+    m_cond_init(out->rw_done);                                          \
+    m_cond_init(out->there_is_data);                                    \
+    out->self = out;                                                    \
+    out->read_count = 0;                                                \
+    out->writer_waiting = false;                                        \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _internal_clear)(concurrent_t out)                          \
+  {                                                                     \
+    assert (out->self == out);                                          \
+    m_mutex_clear(out->lock);                                           \
+    m_cond_clear(out->rw_done);                                         \
+    m_cond_clear(out->there_is_data);                                   \
+    out->self = NULL;                                                   \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _read_lock)(const concurrent_t out)                         \
+  {                                                                     \
+    struct M_C(name, _s) *self = out->self;                             \
+    assert (self == out);                                               \
+    m_mutex_lock (self->lock);                                          \
+    while (self->writer_waiting == true) {                              \
+      m_cond_wait(self->rw_done, self->lock);                           \
+    }                                                                   \
+    self->read_count ++;                                                \
+    m_mutex_unlock (self->lock);                                        \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _read_unlock)(const concurrent_t out)                       \
+  {                                                                     \
+    struct M_C(name, _s) *self = out->self;                             \
+    assert (self == out);                                               \
+    m_mutex_lock (self->lock);                                          \
+    self->read_count --;                                                \
+    if (self->read_count == 0) {                                        \
+      m_cond_broadcast (self->rw_done);                                 \
+    }                                                                   \
+    m_mutex_unlock (self->lock);                                        \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _write_lock)(concurrent_t out)                              \
+  {                                                                     \
+    m_mutex_lock (out->lock);                                           \
+    while (out->writer_waiting == true) {                               \
+      m_cond_wait(out->rw_done, out->lock);                             \
+    }                                                                   \
+    out->writer_waiting = true;                                         \
+    while (out->read_count > 0) {                                       \
+      m_cond_wait(out->rw_done, out->lock);                             \
+    }                                                                   \
+    m_mutex_unlock (out->lock);                                         \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _write_unlock)(concurrent_t out)                            \
+  {                                                                     \
+    m_mutex_lock (out->lock);                                           \
+    out->writer_waiting = false;                                        \
+    m_cond_broadcast (out->rw_done);                                    \
+    m_mutex_unlock (out->lock);                                         \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _read_wait)(const concurrent_t out)                         \
+  {                                                                     \
+    struct M_C(name, _s) *self = out->self;                             \
+    assert (self == out);                                               \
+    m_mutex_lock (out->self->lock);                                     \
+    self->read_count --;                                                \
+    if (self->read_count == 0) {                                        \
+      m_cond_broadcast (self->rw_done);                                 \
+    }                                                                   \
+    m_cond_wait(self->there_is_data, self->lock);                       \
+    while (self->writer_waiting == true) {                              \
+      m_cond_wait(self->rw_done, self->lock);                           \
+    }                                                                   \
+    self->read_count ++;                                                \
+    m_mutex_unlock (out->self->lock);                                   \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _write_wait)(concurrent_t out)                              \
+  {                                                                     \
+    m_mutex_lock (out->lock);                                           \
+    out->writer_waiting = false;                                        \
+    m_cond_broadcast (out->rw_done);                                    \
+    m_cond_wait(out->there_is_data, out->lock);                         \
+    while (out->writer_waiting == true) {                               \
+      m_cond_wait(out->rw_done, out->lock);                             \
+    }                                                                   \
+    out->writer_waiting = true;                                         \
+    while (out->read_count > 0) {                                       \
+      m_cond_wait(out->rw_done, out->lock);                             \
+    }                                                                   \
+    m_mutex_unlock (out->lock);                                         \
+  }                                                                     \
+                                                                        \
+  static inline void                                                    \
+  M_C(name, _write_signal)(concurrent_t out)                            \
+  {                                                                     \
+    m_mutex_lock (out->lock);                                           \
+    m_cond_broadcast(out->there_is_data);                               \
+    m_mutex_unlock (out->lock);                                         \
+  }                                                                     \
+                                                                        \
+  CONCURRENTI_DEF_FUNC_P3(name, type, oplist, concurrent_t)
+
+
+#endif

m-deque.h

@@ -1,7 +1,7 @@
 /*
  * M*LIB - DEQUE module
  *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2020, 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:
@@ -22,38 +22,34 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#ifndef __M_DEQUE_H
-#define __M_DEQUE_H
+#ifndef MSTARLIB_DEQUE_H
+#define MSTARLIB_DEQUE_H
 
 #include "m-i-list.h"
 
-/* Define a deque of a given type.
+/* Define a deque of a given type and its associated functions.
    USAGE: DEQUE_DEF(name, type [, oplist_of_the_type]) */
 #define DEQUE_DEF(name, ...)                                            \
-  DEQUEI_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                                \
-             ((name, __VA_ARGS__, M_DEFAULT_OPLIST, M_C(name,_t), M_C(name,_it_t), M_C(name, _node_t) ), \
-              (name, __VA_ARGS__,                   M_C(name,_t), M_C(name,_it_t), M_C(name, _node_t) )))
+  DEQUEI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
+                ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name,_t), M_C(name,_it_t), M_C(name, _node_t) ), \
+                 (name, __VA_ARGS__,                                        M_C(name,_t), M_C(name,_it_t), M_C(name, _node_t))))
 
 
-/* Define the oplist of a deque of type.
+/* Define the oplist of a deque of a type.
    USAGE: DEQUE_OPLIST(name[, oplist of the type]) */
 #define DEQUE_OPLIST(...)                                            \
-  DEQUEI_OPLIST (M_IF_NARGS_EQ1(__VA_ARGS__)                         \
-                 ((__VA_ARGS__, M_DEFAULT_OPLIST ),                  \
-                  (__VA_ARGS__ )))
+  DEQUEI_OPLIST_P1 (M_IF_NARGS_EQ1(__VA_ARGS__)                      \
+                    ((__VA_ARGS__, M_DEFAULT_OPLIST),		     \
+                     (__VA_ARGS__ )))
 
 /********************************** INTERNAL ************************************/
 
+/* Default initial size of a bucket of items */
+#ifndef DEQUEUI_DEFAULT_SIZE
 #define DEQUEUI_DEFAULT_SIZE  8
-
-/* C++ doesn't support flexible array within a structure.
-   Let's define at least one element. */
-#ifdef __cplusplus
-# define DEQUEI_MIN_ARRAY_SIZE 1
-#else
-# define DEQUEI_MIN_ARRAY_SIZE 
 #endif
 
+/* Define the internal contract of a deque */
 #define DEQUEI_CONTRACT(d) do {						\
     assert ((d) != NULL);						\
     assert ((d)->default_size >= DEQUEUI_DEFAULT_SIZE);			\
@@ -67,23 +63,63 @@
 	    (d)->back->index - (d)->front->index == (d)->count);	\
   } while (0)
 
-#define DEQUEI_DEF(arg) DEQUEI_DEF2 arg
+/* Deferred evaluation for the deque definition,
+   so that all arguments are evaluated before further expansion */
+#define DEQUEI_DEF_P1(arg) DEQUEI_DEF_P2 arg
 
-#define DEQUEI_DEF2(name, type, oplist, deque_t, it_t, node_t)		\
+/* Validate the oplist before going further */
+#define DEQUEI_DEF_P2(name, type, oplist, deque_t, it_t, node_t)        \
+  M_IF_OPLIST(oplist)(DEQUEI_DEF_P3, DEQUEI_DEF_FAILURE)(name, type, oplist, deque_t, it_t, node_t)
+
+/* Stop processing with a compilation failure */
+#define DEQUEI_DEF_FAILURE(name, type, oplist, deque_t, it_t, node_t)   \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(DEQUE_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* Internal deque definition
+   - name: prefix to be used
+   - type: type of the elements of the deque
+   - oplist: oplist of the type of the elements of the container
+   - deque_t: alias for M_C(name, _t) [ type of the container ]
+   - it_t: alias for M_C(name, _it_t) [ iterator of the container ]
+   - node_t: alias for M_C(name, _node_t) [ node ]
+ */
+#define DEQUEI_DEF_P3(name, type, oplist, deque_t, it_t, node_t)        \
 									\
+  /* It is a linked list of buckets of the types,                       \
+     each new created bucket size grows compared to the previous one    \
+     resulting in:                                                      \
+     strict O(1) for push/pop                                           \
+     O(ln(n)) for random access.                                        \
+     No insert / delete operations are planned.                         \
+     [Could be done in O(n) complexity if needed]                       \
+     Define the bucket (aka node) structure.                            \
+  */                                                                    \
   typedef struct M_C(name, _node_s) {					\
     ILIST_INTERFACE(M_C(name, _node_list), struct M_C(name, _node_s));	\
     size_t size;							\
-    type  data[DEQUEI_MIN_ARRAY_SIZE];					\
+    type  data[M_MIN_FLEX_ARRAY_SIZE];					\
   } node_t;								\
-									\
+                                                                        \
+  /* Each node is allocated with a variable size bucket (so we use      \
+     M_GET_REALLOC for the allocation). But we want to delete the nodes \
+     automatically with the intrusive list used for storing the nodes:  \
+     so we register as a DEL operator the FREE operator of the oplist.  \
+     The interfaces are compatible.                                     \
+  */                                                                    \
   ILIST_DEF(M_C(name, _node_list), node_t, (DEL(M_GET_FREE oplist)) )	\
   									\
+  /* Define an internal iterator */                                     \
   typedef struct M_C(name, _it2_s) {					\
     node_t *node;							\
     size_t        index;						\
   } M_C(name, _it2_t)[1];						\
   									\
+  /* Define the deque type:                                             \
+     - 'list' if the list of buckets containing the objects.            \
+     - 'front' and 'back' are iterators to the first and last elements. \
+     - 'default_size' is the size used for the creation of a new bucket \
+     - 'count' is the number of elements in the container.              \
+  */                                                                    \
   typedef struct M_C(name, _s) {					\
     M_C(name, _node_list_t) list;					\
     M_C(name, _it2_t)       front;					\
@@ -91,6 +127,9 @@
     size_t                  default_size;				\
     size_t                  count;					\
   } deque_t[1];								\
+                                                                        \
+  typedef struct M_C(name, _s) *M_C(name, _ptr);                        \
+  typedef const struct M_C(name, _s) *M_C(name, _srcptr);               \
 		 							\
   typedef struct M_C(name, _it_s) {					\
     node_t *node;							\
@@ -100,26 +139,32 @@
   									\
   typedef type M_C(name, _type_t);					\
   									\
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                      \
+                                                                        \
   static inline M_C(name, _node_t)*                                     \
   M_C(name, _int_new_node)(deque_t d)					\
   {									\
     size_t def = d->default_size;					\
-    if (M_UNLIKELY (def >SIZE_MAX / sizeof (type) - sizeof(M_C(name, _node_t)))) { \
+    /* Test for overflow of the size computation */                     \
+    if (M_UNLIKELY (def > SIZE_MAX / sizeof (type) - sizeof(M_C(name, _node_t)))) { \
       M_MEMORY_FULL(sizeof(M_C(name, _node_t))+def * sizeof(type));     \
       return NULL;							\
     }									\
+    /* Alloc a new node */                                              \
     M_C(name, _node_t)*n = (M_C(name, _node_t)*) (void*)                \
-      M_GET_REALLOC oplist (char, NULL,					\
-			    sizeof(M_C(name, _node_t)) + def * sizeof(type) ); \
+      M_CALL_REALLOC(oplist, char, NULL,                                \
+                     sizeof(M_C(name, _node_t)) + def * sizeof(type) ); \
     if (n==NULL) {							\
       M_MEMORY_FULL(sizeof(M_C(name, _node_t))+def * sizeof(type));     \
       return NULL;							\
     }									\
+    /* Initialize the node */                                           \
     n->size = def;							\
     M_C(name, _node_list_init_field)(n);                                \
+    /* Increase the next bucket allocation */                           \
     /* Do not increase it too much if there are few items */            \
     def = M_MIN(def, d->count);                                         \
-    d->default_size = M_GET_INC_ALLOC oplist (def);                     \
+    d->default_size = M_CALL_INC_ALLOC(oplist, def);                    \
     return n;								\
   }									\
 									\
@@ -143,18 +188,17 @@
   M_C(name, _clean)(deque_t d)						\
   {									\
     DEQUEI_CONTRACT(d);							\
-    M_C(name, _node_list_it_t) it;					\
     M_C(name, _node_t) *min_node = NULL;                                \
-    for(M_C(name, _node_list_it)(it, d->list) ;				\
-	!M_C(name, _node_list_end_p)(it) ;				\
-	M_C(name, _node_list_next)(it) ){				\
-      M_C(name, _node_t) *n = M_C(name, _node_list_ref)(it);            \
-      size_t min = n == d->front->node ? d->back->index + 1 : 0;	\
-      size_t max = n == d->back->node ? d->back->index + 1: n->size;	\
+    for(M_C(name, _node_t) *n = d->front->node;                         \
+	n != NULL ;                                                     \
+	n = (n == d->back->node) ? NULL :                               \
+          M_C(name, _node_list_next_obj)(d->list, n) ){                 \
+      size_t min = n == d->front->node ? d->front->index : 0;		\
+      size_t max = n == d->back->node ? d->back->index : n->size;	\
       for(size_t i = min; i < max; i++) {				\
-	M_GET_CLEAR oplist (n->data[i]);				\
+	M_CALL_CLEAR(oplist, n->data[i]);				\
       }									\
-      min_node = min_node == NULL || min_node->size > n->size ? n : min_node; \
+      min_node = (min_node == NULL || min_node->size > n->size) ? n : min_node; \
     }									\
     assert (min_node != NULL);                                          \
     d->front->node = min_node;						\
@@ -170,9 +214,9 @@
   {									\
     DEQUEI_CONTRACT(d);							\
     M_C(name, _clean)(d);						\
-    /* We registered the delete operator to clear all objects	*/	\
+    /* We have registered the delete operator to clear all objects */   \
     M_C(name, _node_list_clear)(d->list);				\
-    /* It is safer to clean some variables*/				\
+    /* It is safer to clean some variables */				\
     d->front->node  = NULL;						\
     d->back->node   = NULL;						\
     d->count = 0;							\
@@ -185,8 +229,10 @@
     M_C(name, _node_t) *n = d->back->node;                              \
     size_t index = d->back->index;					\
     if (M_UNLIKELY (n->size <= index)) {				\
+      /* try to get an already allocated node */                        \
       n = M_C(name, _node_list_next_obj)(d->list, n);			\
       if (n == NULL) {							\
+        /* No node exists, allocate a new one */                        \
 	n = M_C(name, _int_new_node)(d);				\
 	if (M_UNLIKELY (n == NULL)) return NULL;			\
 	M_C(name, _node_list_push_back)(d->list, n);			\
@@ -207,18 +253,30 @@
   {									\
     type *p = M_C(name, _push_back_raw)(d);				\
     if (M_LIKELY(p != NULL)) {						\
-      M_GET_INIT_SET oplist (*p, x);					\
+      M_CALL_INIT_SET(oplist, *p, x);					\
     }									\
   }									\
 									\
+  M_IF_METHOD(INIT, oplist)(                                            \
   static inline type *							\
   M_C(name, _push_back_new)(deque_t d)					\
   {									\
     type *p = M_C(name, _push_back_raw)(d);				\
     if (M_LIKELY(p != NULL)) {						\
-      M_GET_INIT oplist (*p);						\
+      M_CALL_INIT(oplist, *p);						\
     }									\
     return p;								\
+  }									\
+  , )                                                                   \
+									\
+  static inline void							\
+  M_C(name, _push_back_move)(deque_t d, type *x)			\
+  {									\
+    assert (x != NULL);                                                 \
+    type *p = M_C(name, _push_back_raw)(d);				\
+    if (M_UNLIKELY(p == NULL)) 						\
+      return;                                                           \
+    M_DO_INIT_MOVE (oplist, *p, *x);					\
   }									\
 									\
   static inline type*							\
@@ -251,18 +309,30 @@
   {									\
     type *p = M_C(name, _push_front_raw)(d);				\
     if (M_LIKELY(p != NULL)) {						\
-      M_GET_INIT_SET oplist (*p, x);					\
+      M_CALL_INIT_SET(oplist, *p, x);					\
     }									\
   }									\
 									\
+  M_IF_METHOD(INIT, oplist)(                                            \
   static inline type *							\
   M_C(name, _push_front_new)(deque_t d)					\
   {									\
     type *p = M_C(name, _push_front_raw)(d);				\
     if (M_LIKELY(p != NULL)) {						\
-      M_GET_INIT oplist (*p);						\
+      M_CALL_INIT(oplist, *p);						\
     }									\
     return p;								\
+  }									\
+  ,)                                                                    \
+									\
+  static inline void							\
+  M_C(name, _push_front_move)(deque_t d, type *x)			\
+  {									\
+    assert (x != NULL);                                                 \
+    type *p = M_C(name, _push_front_raw)(d);				\
+    if (M_UNLIKELY(p == NULL)) 						\
+      return;                                                           \
+    M_DO_INIT_MOVE (oplist, *p, *x);					\
   }									\
 									\
   static inline void							\
@@ -290,16 +360,27 @@
     }									\
     if (ptr != NULL)							\
       M_IF_METHOD(MOVE, oplist) (                                       \
-      M_GET_MOVE oplist(*ptr, n->data[index]); else                     \
+      M_CALL_MOVE(oplist, *ptr, n->data[index]); else                   \
       ,                                                                 \
-      M_GET_SET oplist(*ptr, n->data[index]);				\
+      M_CALL_SET(oplist, *ptr, n->data[index]);				\
       )                                                                 \
-    M_GET_CLEAR oplist (n->data[index]);				\
+    M_CALL_CLEAR(oplist,  n->data[index]);				\
     d->count --;							\
     d->back->index = index;						\
     DEQUEI_CONTRACT(d);							\
   }									\
 									\
+  M_IF_METHOD(INIT, oplist)(                                            \
+  static inline void							\
+  M_C(name, _pop_back_move)(type *ptr, deque_t d)			\
+  {									\
+    assert(ptr != NULL);                                                \
+    /* Note: Lazy implementation. Can be improved if needed */          \
+    M_CALL_INIT(oplist, *ptr);                                          \
+    M_C(name, _pop_back)(ptr, d);                                       \
+  }                                                                     \
+  , )                                                                   \
+									\
   static inline void							\
   M_C(name, _pop_front)(type *ptr, deque_t d)				\
   {									\
@@ -324,16 +405,27 @@
     }									\
     if (ptr != NULL)							\
       M_IF_METHOD(MOVE, oplist) (                                       \
-      M_GET_MOVE oplist(*ptr, n->data[index]); else                     \
+      M_CALL_MOVE(oplist, *ptr, n->data[index]); else                   \
       ,                                                                 \
-      M_GET_SET oplist(*ptr, n->data[index]);				\
+      M_CALL_SET(oplist, *ptr, n->data[index]);				\
       )                                                                 \
-    M_GET_CLEAR oplist (n->data[index]);				\
+    M_CALL_CLEAR(oplist, n->data[index]);				\
     index++;								\
     d->count --;							\
     d->front->index = index;						\
   }									\
 									\
+  M_IF_METHOD(INIT, oplist)(                                            \
+  static inline void							\
+  M_C(name, _pop_front_move)(type *ptr, deque_t d)			\
+  {									\
+    assert(ptr != NULL);                                                \
+    /* Note: Lazy implementation */                                     \
+    M_CALL_INIT(oplist, *ptr);                                          \
+    M_C(name, _pop_front)(ptr, d);                                      \
+  }                                                                     \
+  ,)                                                                    \
+                                                                        \
   static inline type *							\
   M_C(name, _back)(const deque_t d)					\
   {									\
@@ -370,6 +462,40 @@
     DEQUEI_CONTRACT(d);							\
     return d->count;							\
   }									\
+                                                                        \
+  static inline size_t                                                  \
+  M_C(name, _capacity_back)(const deque_t v)                            \
+  {                                                                     \
+    DEQUEI_CONTRACT(v);                                                 \
+    size_t s = 0;                                                       \
+    for(M_C(name, _node_t) *n = M_C(name, _node_list_back)(v->list);    \
+	n != NULL ;                                                     \
+	n = (n == v->back->node) ? NULL :                               \
+          M_C(name, _node_list_previous_obj)(v->list, n) ){             \
+      s += (n == v->back->node ? v->back->index : n->size);             \
+    }                                                                   \
+    return s;                                                           \
+  }                                                                     \
+                                                                        \
+  static inline size_t                                                  \
+  M_C(name, _capacity_front)(const deque_t v)                           \
+  {                                                                     \
+    DEQUEI_CONTRACT(v);                                                 \
+    size_t s = 0;                                                       \
+    for(M_C(name, _node_t) *n = M_C(name, _node_list_front)(v->list);   \
+	n != NULL ;                                                     \
+	n = (n == v->front->node) ? NULL :                              \
+          M_C(name, _node_list_next_obj)(v->list, n) ){                 \
+      s += n->size - (n == v->front->node ? v->front->index : 0);       \
+    }                                                                   \
+    return s;                                                           \
+  }                                                                     \
+                                                                        \
+  static inline size_t                                                  \
+  M_C(name, _capacity)(const deque_t v)					\
+  {                                                                     \
+    return M_C(name, _capacity_back)(v)+M_C(name, _capacity_front)(v);  \
+  }                                                                     \
 									\
   static inline bool							\
   M_C(name, _empty_p)(const deque_t d)					\
@@ -499,7 +625,7 @@
     return &it->node->data[it->index];					\
   }									\
 									\
-  static inline const type *						\
+  static inline type const *						\
   M_C(name, _cref)(it_t it)						\
   {									\
     assert (it != NULL);						\
@@ -526,8 +652,8 @@
     it_t it;								\
     size_t i = DEQUEUI_DEFAULT_SIZE/2;					\
     for(M_C(name, _it)(it, src); !M_C(name, _end_p)(it) ; M_C(name, _next)(it)) { \
-      const type *obj = M_C(name, _cref)(it);				\
-      M_GET_INIT_SET oplist (n->data[i], *obj);				\
+      type const *obj = M_C(name, _cref)(it);				\
+      M_CALL_INIT_SET(oplist, n->data[i], *obj);                        \
       i++;								\
       assert (i <= d->back->index);					\
     }									\
@@ -535,7 +661,7 @@
   }									\
 									\
   static inline void							\
-  M_C(name, _set)(deque_t d, deque_t src)				\
+  M_C(name, _set)(deque_t d, deque_t const src)				\
   {									\
     if (M_UNLIKELY (src == d))						\
       return;								\
@@ -549,7 +675,13 @@
   {									\
     DEQUEI_CONTRACT(src);						\
     assert (d!= NULL);							\
-    memcpy(d, src, sizeof(deque_t));					\
+    M_C(name,_node_list_init_move)(d->list, src->list);                 \
+    d->front->node  = src->front->node;                                 \
+    d->front->index = src->front->index;                                \
+    d->back->node   = src->back->node;                                  \
+    d->back->index  = src->back->index;                                 \
+    d->default_size = src->default_size;                                \
+    d->count        = src->count;                                       \
     memset(src, 0, sizeof(deque_t));					\
     DEQUEI_CONTRACT(d);							\
   }									\
@@ -587,12 +719,11 @@
     assert (key < d->count);						\
     const size_t index0 = d->front->index;				\
     size_t count = 0;							\
-    M_C(name, _node_list_it_t) it;					\
     /* This loop is in log(N) since the size increase exponentially.*/	\
-    for(M_C(name, _node_list_it)(it, d->list) ;				\
-	!M_C(name, _node_list_end_p)(it) ;				\
-	M_C(name, _node_list_next)(it) ){				\
-      M_C(name, _node_t) *n = M_C(name, _node_list_ref)(it);            \
+    for(M_C(name, _node_t) *n = d->front->node;                         \
+	n != NULL ;                                                     \
+	n = (n == d->back->node) ? NULL :                               \
+          M_C(name, _node_list_next_obj)(d->list, n) ){                 \
       if (index0 + key < count + n->size) {				\
 	return &n->data[index0 + key - count];				\
       }									\
@@ -602,7 +733,7 @@
     return NULL;							\
   }									\
 									\
-  static inline const type *						\
+  static inline type const *						\
   M_C(name, _cget)(deque_t d, size_t key)				\
   {									\
     return M_CONST_CAST(type, M_C(name, _get)(d, key));			\
@@ -614,7 +745,7 @@
     DEQUEI_CONTRACT(d);							\
     assert (key < d->count);						\
     type *p = M_C(name, _get)(d, key);					\
-    M_GET_SET oplist (*p, x);						\
+    M_CALL_SET(oplist, *p, x);						\
   }									\
 									\
   M_IF_METHOD(EQUAL, oplist)(						\
@@ -630,9 +761,9 @@
     for(M_C(name, _it)(it1, d1), M_C(name,_it)(it2, d2);		\
 	!M_C(name, _end_p)(it1) ;					\
 	M_C(name, _next)(it1), M_C(name, _next)(it2)) {			\
-      const type *obj1 = M_C(name, _cref)(it1);				\
-      const type *obj2 = M_C(name, _cref)(it2);				\
-      if (M_GET_EQUAL oplist (*obj1, *obj2) == false)			\
+      type const *obj1 = M_C(name, _cref)(it1);				\
+      type const *obj2 = M_C(name, _cref)(it2);				\
+      if (M_CALL_EQUAL(oplist, *obj1, *obj2) == false)			\
 	return false;							\
     }									\
     assert (M_C(name, _end_p)(it2));					\
@@ -648,8 +779,8 @@
     M_HASH_DECL(hash);							\
     it_t it;								\
     for(M_C(name, _it)(it, d); !M_C(name, _end_p)(it); M_C(name, _next)(it)) { \
-      const type *obj = M_C(name, _cref)(it);				\
-      M_HASH_UP (hash, M_GET_HASH oplist (*obj));			\
+      type const *obj = M_C(name, _cref)(it);				\
+      M_HASH_UP (hash, M_CALL_HASH(oplist, *obj));			\
     }									\
     return M_HASH_FINAL(hash);						\
   }									\
@@ -664,14 +795,14 @@
     assert (j < d->count);						\
     type *obj1 = M_C(name, _get)(d, i);					\
     type *obj2 = M_C(name, _get)(d, j);					\
-    M_GET_SWAP oplist (*obj1, *obj2);					\
+    M_CALL_SWAP(oplist, *obj1, *obj2);					\
     DEQUEI_CONTRACT(d);							\
   }									\
-  , /* NO SWAP: TODO */)						\
+  , /* NO SWAP */)                                                      \
                                                                         \
   M_IF_METHOD(GET_STR, oplist)(                                         \
   static inline void                                                    \
-  M_C(name, _get_str)(string_t str, deque_t deque, bool append)         \
+  M_C(name, _get_str)(string_t str, deque_t const deque, bool append)	\
   {                                                                     \
     STRINGI_CONTRACT(str);                                              \
     DEQUEI_CONTRACT(deque);                                             \
@@ -680,8 +811,8 @@
     for (M_C(name, _it)(it, deque) ;					\
          !M_C(name, _end_p)(it);					\
          M_C(name, _next)(it)){						\
-      const type *item = M_C(name, _cref)(it);				\
-      M_GET_GET_STR oplist (str, *item, true);                          \
+      type const *item = M_C(name, _cref)(it);				\
+      M_CALL_GET_STR(oplist, str, *item, true);                         \
       if (!M_C(name, _last_p)(it))					\
         string_push_back (str, M_GET_SEPARATOR oplist);                 \
     }                                                                   \
@@ -701,8 +832,8 @@
     for (M_C(name, _it)(it, deque) ;					\
          !M_C(name, _end_p)(it);					\
          M_C(name, _next)(it)) {                                        \
-      const type *item = M_C(name, _cref)(it);				\
-      M_GET_OUT_STR oplist (file, *item);                               \
+      type const *item = M_C(name, _cref)(it);				\
+      M_CALL_OUT_STR(oplist, file, *item);                              \
       if (!M_C(name, _last_p)(it))					\
         fputc (M_GET_SEPARATOR oplist, file);                           \
     }                                                                   \
@@ -710,7 +841,39 @@
   }                                                                     \
   , /* no OUT_STR */ )                                                  \
                                                                         \
-  M_IF_METHOD(IN_STR, oplist)(                                          \
+  M_IF_METHOD2(PARSE_STR, INIT, oplist)(                                \
+  static inline bool                                                    \
+  M_C(name, _parse_str)(deque_t deque, const char str[], const char **endp) \
+  {                                                                     \
+    DEQUEI_CONTRACT(deque);                                             \
+    assert (str != NULL);                                               \
+    M_C(name,_clean)(deque);                                            \
+    bool success = false;                                               \
+    int c = *str++;                                                     \
+    if (M_UNLIKELY (c != '[')) goto exit;                               \
+    c = *str++;                                                         \
+    if (M_UNLIKELY (c == ']')) {success = true; goto exit;}             \
+    if (M_UNLIKELY (c == 0)) goto exit;                                 \
+    str--;                                                              \
+    type item;                                                          \
+    M_CALL_INIT(oplist, item);                                          \
+    do {                                                                \
+      bool b = M_CALL_PARSE_STR(oplist, item, str, &str);               \
+      do { c = *str++; } while (isspace(c));                            \
+      if (b == false || c == 0) { goto exit_clear; }                    \
+      M_C(name, _push_back)(deque, item);                               \
+    } while (c == M_GET_SEPARATOR oplist);                              \
+    DEQUEI_CONTRACT(deque);                                             \
+    success = (c == ']');                                               \
+  exit_clear:                                                           \
+    M_CALL_CLEAR(oplist, item);                                         \
+  exit:                                                                 \
+    if (endp) *endp = str;                                              \
+    return success;                                                     \
+  }                                                                     \
+  , /* no PARSE_STR */ )                                                \
+                                                                        \
+  M_IF_METHOD2(IN_STR, INIT, oplist)(                                   \
   static inline bool                                                    \
   M_C(name, _in_str)(deque_t deque, FILE *file)				\
   {                                                                     \
@@ -724,25 +887,86 @@
     if (M_UNLIKELY (c == EOF)) return false;                            \
     ungetc(c, file);                                                    \
     type item;                                                          \
-    M_GET_INIT oplist (item);                                           \
+    M_CALL_INIT(oplist, item);                                          \
     do {                                                                \
-      bool b = M_GET_IN_STR oplist (item, file);                        \
-      c = fgetc(file);                                                  \
+      bool b = M_CALL_IN_STR(oplist, item, file);                       \
+      do { c = fgetc(file); } while (isspace(c));                       \
       if (b == false || c == EOF) { break; }				\
       M_C(name, _push_back)(deque, item);				\
     } while (c == M_GET_SEPARATOR oplist);				\
-    M_GET_CLEAR oplist (item);                                          \
+    M_CALL_CLEAR(oplist, item);                                         \
     DEQUEI_CONTRACT(deque);                                             \
     return c == ']';                                                    \
   }                                                                     \
   , /* no IN_STR */ )                                                   \
+                                                                        \
+  M_IF_METHOD(OUT_SERIAL, oplist)(                                      \
+  static inline m_serial_return_code_t                                  \
+  M_C(name, _out_serial)(m_serial_write_t f, const deque_t deque)       \
+  {                                                                     \
+    DEQUEI_CONTRACT(deque);                                             \
+    assert (f != NULL && f->m_interface != NULL);                         \
+    m_serial_local_t local;                                             \
+    m_serial_return_code_t ret;                                         \
+    bool first_done = false;                                            \
+    ret = f->m_interface->write_array_start(local, f, deque->count);      \
+    M_C(name, _it_t) it;						\
+    for (M_C(name, _it)(it, deque) ;					\
+         !M_C(name, _end_p)(it);					\
+         M_C(name, _next)(it)){						\
+      type const *item = M_C(name, _cref)(it);				\
+      if (first_done)                                                   \
+        ret |= f->m_interface->write_array_next(local, f);                \
+      ret |= M_CALL_OUT_SERIAL(oplist, f, *item);                       \
+      first_done = true;                                                \
+    }                                                                   \
+    ret |= f->m_interface->write_array_end(local, f);                     \
+    return ret & M_SERIAL_FAIL;                                         \
+  }                                                                     \
+  , /* no OUT_SERIAL */ )                                               \
+                                                                        \
+  M_IF_METHOD2(IN_SERIAL, INIT, oplist)(                                \
+  static inline m_serial_return_code_t                                  \
+  M_C(name, _in_serial)(deque_t deque, m_serial_read_t f)               \
+  {                                                                     \
+    DEQUEI_CONTRACT(deque);                                             \
+    assert (f != NULL && f->m_interface != NULL);                         \
+    m_serial_local_t local;                                             \
+    m_serial_return_code_t ret;                                         \
+    size_t estimated_size = 0;                                          \
+    M_C(name,_clean)(deque);						\
+    ret = f->m_interface->read_array_start(local, f, &estimated_size);    \
+    if (M_UNLIKELY (ret != M_SERIAL_OK_CONTINUE)) return ret;           \
+    type item;                                                          \
+    M_CALL_INIT(oplist, item);                                          \
+    do {                                                                \
+      ret = M_CALL_IN_SERIAL(oplist, item, f);                          \
+      if (ret != M_SERIAL_OK_DONE) { break; }				\
+      M_C(name, _push_back)(deque, item);				\
+    } while ((ret = f->m_interface->read_array_next(local, f)) == M_SERIAL_OK_CONTINUE); \
+    M_CALL_CLEAR(oplist, item);                                         \
+    return ret;                                                         \
+  }                                                                     \
+  , /* no IN_SERIAL & INIT */ )                                         \
+                                                                        \
 
+/* Deferred evaluation for the oplist definition,
+   so that all arguments are evaluated before further expansion */
+#define DEQUEI_OPLIST_P1(arg) DEQUEI_OPLIST_P2 arg
 
-#define DEQUEI_OPLIST(arg) DEQUEI_OPLIST2 arg
+/* Validation of the given oplist */
+#define DEQUEI_OPLIST_P2(name, oplist)					\
+  M_IF_OPLIST(oplist)(DEQUEI_OPLIST_P3, DEQUEI_OPLIST_FAILURE)(name, oplist)
 
-#define DEQUEI_OPLIST2(name, oplist)					\
+/* Prepare a clean compilation failure */
+#define DEQUEI_OPLIST_FAILURE(name, oplist)		\
+  M_LIB_ERROR(ARGUMENT_OF_DEQUE_OPLIST_IS_NOT_AN_OPLIST, name, oplist)
+
+/* OPLIST definition of a deque */
+#define DEQUEI_OPLIST_P3(name, oplist)					\
   (INIT(M_C(name, _init))						\
    ,INIT_SET(M_C(name, _init_set))					\
+   ,INIT_WITH(API_1(M_INIT_VAI))                                        \
    ,SET(M_C(name, _set))						\
    ,CLEAR(M_C(name, _clear))						\
    ,INIT_MOVE(M_C(name, _init_move))					\
@@ -750,6 +974,7 @@
    ,SWAP(M_C(name, _swap))						\
    ,TYPE(M_C(name,_t))							\
    ,SUBTYPE(M_C(name, _type_t))						\
+   ,TEST_EMPTY(M_C(name,_empty_p))                                      \
    ,IT_TYPE(M_C(name,_it_t))						\
    ,IT_FIRST(M_C(name,_it))						\
    ,IT_LAST(M_C(name,_it_last))						\
@@ -763,12 +988,16 @@
    ,IT_REF(M_C(name,_ref))						\
    ,IT_CREF(M_C(name,_cref))						\
    ,CLEAN(M_C(name,_clean))						\
+   ,GET_SIZE(M_C(name, _size))                                          \
    ,PUSH(M_C(name,_push_back))						\
    ,POP(M_C(name,_pop_back))						\
    ,OPLIST(oplist)                                                      \
    ,M_IF_METHOD(GET_STR, oplist)(GET_STR(M_C(name, _get_str)),)		\
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(M_C(name, _parse_str)),)   \
    ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_C(name, _out_str)),)		\
    ,M_IF_METHOD(IN_STR, oplist)(IN_STR(M_C(name, _in_str)),)		\
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(M_C(name, _out_serial)),) \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(M_C(name, _in_serial)),)   \
    ,M_IF_METHOD(EQUAL, oplist)(EQUAL(M_C(name, _equal_p)),)		\
    ,M_IF_METHOD(HASH, oplist)(HASH(M_C(name, _hash)),)			\
    ,M_IF_METHOD(NEW, oplist)(NEW(M_GET_NEW oplist),)                    \

m-funcobj.h

@@ -0,0 +1,345 @@
+/*
+ * M*LIB - Function Object module
+ *
+ * Copyright (c) 2017-2020, 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.
+*/
+#ifndef MSTARLIB_FUNCOBJ_H
+#define MSTARLIB_FUNCOBJ_H
+
+#include "m-core.h"
+
+/* Define a function object interface of name 'name'
+ * with a function like retcode, type of param1, type of param 2, ...
+ * USAGE:
+ *    FUNC_OBJ_ITF_DEF(name, retcode type, type of param1, type of param 2, ...)
+ */
+#define FUNC_OBJ_ITF_DEF(name, ...)                                     \
+  M_IF_NARGS_EQ1(__VA_ARGS__)(FUNCOBJI_ITF_NO_PARAM_DEF, FUNCOBJI_ITF_PARAM_DEF)(name, __VA_ARGS__)
+
+
+/* Define a function object instance of name 'name' based on the interface 'base_name'
+ * The function is defined as per :
+ * - the prototype of the inherited interface
+ * - the parameters of the function are named as per the list param_list
+ * - the core of the function shall be defined in callback_core
+ * - optionals member attributes of the function object can be defined after the core
+ * (just like for tuple & variant: (name, type [, oplist])
+ * 
+ * In the core of the function, parameters are accessible just like a normal like
+ * and a special variable 'self' which refers to the function object itself
+ * can be used to access member attributes.
+ * 
+ * There shall be **exactly** the same number of parameters in 'param_list' than
+ * the number of parameters of the interface 'base_name'
+ *
+ * USAGE/EXAMPLE:
+ *   FUNC_OBJ_INS_DEF(name, base_name, (param1, ...), { return param1 * self->member1 }, (member1, int), ...)
+ */
+#define FUNC_OBJ_INS_DEF(name, base_name, param_list, ...)              \
+  M_IF_NARGS_EQ1(__VA_ARGS__)(FUNCOBJI_INS_NO_ATTR_DEF, FUNCOBJI_INS_ATTR_DEF)(name, base_name, param_list, __VA_ARGS__)
+
+
+/* OPLIST of the instanced function object
+ * USAGE:
+ *  FUNC_OBJ_INS_OPLIST(name, oplist of the attr1, ...)
+ */
+#define FUNC_OBJ_INS_OPLIST(...)                                        \
+  M_IF_NARGS_EQ1(__VA_ARGS__)(FUNCOBJI_INS_NO_ATTR_OPLIST, FUNCOBJI_INS_ATTR_OPLIST_P1)( __VA_ARGS__)
+
+
+
+/********************************************************************************/
+/********************************** INTERNAL ************************************/
+/********************************************************************************/
+
+/* To be used by M_IF_FUNCOBJ macro.
+   NOTE: It is reversed (0 instead of 1) so that it can be used in M_IF reliabely.
+*/
+#define M_FUNCOBJ_IS_NOT_DEFINED 0
+
+/* Design Constraints:
+ *  callback SHALL be the first member of the structures in all the definitions.
+ *
+ * Structure definitions are specialized in function of the presence or not
+ * of parameters and/or attributes 
+ * FIXME: How to factorize reasonnably well between the definitions?
+ */
+
+/* Specialization of the OPLIST in function if there is at least one member or not */
+#define FUNCOBJI_INS_NO_ATTR_OPLIST(name)				\
+  (NAME(name), TYPE(M_C(name, _t)),                                     \
+   CLEAR(M_C(name, _clear)),                                            \
+   INIT(M_C(name,_init))                                                \
+   )
+
+/* Validate the oplist before going further */
+#define FUNCOBJI_INS_ATTR_OPLIST_P1(name, ...)				\
+  M_IF(M_REDUCE(M_OPLIST_P, M_AND, __VA_ARGS__))(FUNCOBJI_INS_ATTR_OPLIST_P3, FUNCOBJI_INS_ATTR_OPLIST_FAILURE)(name, __VA_ARGS__)
+
+/* Prepare a clean compilation failure */
+#define FUNCOBJI_INS_ATTR_OPLIST_FAILURE(name, ...)			\
+  M_LIB_ERROR(ONE_ARGUMENT_OF_FUNC_OBJ_INS_OPLIST_IS_NOT_AN_OPLIST, name, __VA_ARGS__)
+
+/* Define at least the oplist */
+#define FUNCOBJI_INS_ATTR_OPLIST_P3(name, ...)				\
+  (NAME(name), TYPE(M_C(name, _t)),                                     \
+   INIT_WITH(M_C(name, _init_with)),                                    \
+   CLEAR(M_C(name, _clear)),                                            \
+   M_IF_METHOD_ALL(INIT, __VA_ARGS__)(INIT(M_C(name,_init)),),          \
+   )
+
+
+/* Specialization of the definition a function object interface of name 'name'
+ * with a function like retcode () that doesn't have any input parameters.
+ */
+#define FUNCOBJI_ITF_NO_PARAM_DEF(name, retcode)                        \
+  typedef retcode M_C(name, _retcode_t);                                \
+                                                                        \
+  struct M_C(name, _s);                                                 \
+                                                                        \
+  /* No parameters to the callback */                                   \
+  typedef retcode(*M_C(name, _callback_t))(struct M_C(name, _s) *);     \
+                                                                        \
+  typedef struct M_C(name, _s) {                                        \
+     M_C(name, _callback_t) callback;                                   \
+  } M_C(name, _t)[1];                                                   \
+                                                                        \
+  static inline retcode                                                 \
+  M_C(name, _call)(M_C(name, _t) funcobj)                               \
+  {                                                                     \
+    M_IF(M_KEYWORD_P(void, retcode)) ( /* nothing */,return)            \
+      funcobj->callback(funcobj);                                       \
+  }
+
+
+/* Specialization of the definition a function object interface of name 'name'
+ * with a function like retcode, type of param1, type of param 2, ...
+ * with mandatory input parameters.
+ */
+#define FUNCOBJI_ITF_PARAM_DEF(name, retcode, ...)                      \
+  typedef retcode M_C(name, _retcode_t);                                \
+                                                                        \
+  /* Define types for all paremeters */                                 \
+  M_MAP3(FUNCOBJI_BASE_TYPE, name, __VA_ARGS__)                         \
+                                                                        \
+  struct M_C(name, _s);                                                 \
+                                                                        \
+  typedef retcode(*M_C(name, _callback_t))(struct M_C(name, _s) *, __VA_ARGS__); \
+                                                                        \
+  typedef struct M_C(name, _s) {                                        \
+     M_C(name, _callback_t) callback;                                   \
+  } M_C(name, _t)[1];                                                   \
+                                                                        \
+  static inline retcode                                                 \
+  M_C(name, _call)(M_C(name, _t) funcobj                                \
+                   M_MAP3(FUNCOBJI_BASE_ARGLIST, name, __VA_ARGS__) )   \
+  {                                                                     \
+    M_IF(M_KEYWORD_P(void, retcode)) ( /* nothing */,return)            \
+      funcobj->callback(funcobj M_MAP3(FUNCOBJI_BASE_ARGCALL, name, __VA_ARGS__) ); \
+  }
+
+
+/* Specialization of the definition a function object instance of name 'name'
+ * with no member attribute.
+ */
+#define FUNCOBJI_INS_NO_ATTR_DEF(name, base_name, param_list, callback_core) \
+  typedef struct M_C(name, _s) {                                        \
+    M_C(base_name, _callback_t) callback;                               \
+  } M_C(name, _t)[1];                                                   \
+                                                                        \
+   static inline M_C(base_name, _retcode_t)                             \
+   M_C(name, _callback)(M_C(base_name, _t) _self                        \
+                        M_IF_EMPTY(M_OPFLAT param_list)(                \
+                           /* No param */,                              \
+                           M_MAP3(FUNCOBJI_INS_ARGLIST, base_name, M_OPFLAT param_list)\
+                                                                      ) \
+                       )                                                \
+   {                                                                    \
+     struct M_C(name, _s) *self = (struct M_C(name, _s) *)_self;        \
+     (void) self; /* maybe unused */                                    \
+     callback_core;                                                     \
+   }                                                                    \
+                                                                        \
+   static inline void                                                   \
+   M_C(name, _init_with)(M_C(name, _t) obj)                             \
+   {                                                                    \
+     obj->callback = M_C(name, _callback);                              \
+   }                                                                    \
+                                                                        \
+   static inline void                                                   \
+   M_C(name, _clear)(M_C(name, _t) obj)                                 \
+   {                                                                    \
+     (void) obj; /* nothing to do */                                    \
+   }                                                                    \
+                                                                        \
+   static inline struct M_C(base_name, _s) *                            \
+   M_C(name, _as_interface)(M_C(name, _t) obj)                          \
+   {                                                                    \
+     return (struct M_C(base_name, _s) *) obj;                          \
+   }                                                                    \
+                                                                        \
+   static inline void                                                   \
+   M_C(name, _init)(M_C(name, _t) obj)                                  \
+   {                                                                    \
+     obj->callback = M_C(name, _callback);                              \
+   }                                                                    \
+   
+
+/* Specialization of the definition a function object instance of name 'name'
+ * with mandatory member attribute.
+ * First inject oplist in member attributes.
+ */
+#define FUNCOBJI_INS_ATTR_DEF(name, base_name, param_list, callback_core, ...) \
+  FUNCOBJI_INS_ATTR_DEF_P2(name, base_name, param_list, callback_core, FUNCOBJI_INJECT_GLOBAL(__VA_ARGS__) )
+
+/* Inject the oplist within the list of arguments */
+#define FUNCOBJI_INJECT_GLOBAL(...)               \
+  M_MAP_C(FUNCOBJI_INJECT_OPLIST_A, __VA_ARGS__)
+/* Transform (x, type) into (x, type, oplist) if there is global registered oplist 
+   or (x, type, M_DEFAULT_OPLIST) if there is no global one,
+   or keep (x, type, oplist) if oplist was already present */
+#define FUNCOBJI_INJECT_OPLIST_A( duo_or_trio )   \
+  FUNCOBJI_INJECT_OPLIST_B duo_or_trio
+#define FUNCOBJI_INJECT_OPLIST_B( f, ... )                                \
+  M_IF_NARGS_EQ1(__VA_ARGS__)( (f, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)()), (f, __VA_ARGS__) )
+
+// Test if all third argument of all arguments is an oplist
+#define FUNCOBJI_IF_ALL_OPLIST(...)                               \
+  M_IF(M_REDUCE(FUNCOBJI_IS_OPLIST_P, M_AND, __VA_ARGS__))
+// Test if the third argument is an oplist
+#define FUNCOBJI_IS_OPLIST_P(a)                   \
+  M_OPLIST_P(M_RET_ARG3 a)
+
+/* Validate the oplist before going further */
+#define FUNCOBJI_INS_ATTR_DEF_P2(name, base_name, param_list, callback_core, ...) \
+  FUNCOBJI_IF_ALL_OPLIST(__VA_ARGS__)(FUNCOBJI_INS_ATTR_DEF_P3, FUNCOBJI_INS_ATTR_DEF_FAILURE)(name, base_name, param_list, callback_core, __VA_ARGS__)
+
+/* Stop processing with a compilation failure */
+#define FUNCOBJI_INS_ATTR_DEF_FAILURE(name, base_name, param_list, callback_core, ...) \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(FUNC_OBJ_INS_DEF): at least one of the given argument is not a valid oplist: " #__VA_ARGS__)
+
+/* Expand the Function Object with members */
+#define FUNCOBJI_INS_ATTR_DEF_P3(name, base_name, param_list, callback_core, ...) \
+  typedef struct M_C(name, _s) {                                        \
+    /* Callback is the mandatory first argument */                      \
+    M_C(base_name, _callback_t) callback;                               \
+    /* All the member attribute of the Function Object */               \
+    M_MAP(FUNCOBJI_INS_ATTR_STRUCT, __VA_ARGS__)                        \
+   } M_C(name, _t)[1];                                                  \
+                                                                        \
+   FUNCOBJI_CONTROL_ALL_OPLIST(name, __VA_ARGS__)                       \
+                                                                        \
+   static inline M_C(base_name, _retcode_t)                             \
+   M_C(name, _callback)(M_C(base_name, _t) _self                        \
+                        M_IF_EMPTY(M_OPFLAT param_list)(                \
+                          /* No param */,                               \
+                          M_MAP3(FUNCOBJI_INS_ARGLIST, base_name, M_OPFLAT param_list)\
+                                                                      ) \
+                       )                                                \
+   {                                                                    \
+     struct M_C(name, _s) *self = (struct M_C(name, _s) *)_self;        \
+     (void) self; /* maybe unused */                                    \
+     callback_core;                                                     \
+   }                                                                    \
+                                                                        \
+   static inline void                                                   \
+   M_C(name, _init_with)(M_C(name, _t) obj M_MAP(FUNCOBJI_INS_ATTR_LIST, __VA_ARGS__)) \
+   {                                                                    \
+     obj->callback = M_C(name, _callback);                              \
+     M_MAP(FUNCOBJI_INS_ATTR_INIT_SET, __VA_ARGS__);                    \
+   }                                                                    \
+                                                                        \
+   static inline void                                                   \
+   M_C(name, _clear)(M_C(name, _t) obj)                                 \
+   {                                                                    \
+     M_MAP(FUNCOBJI_INS_ATTR_CLEAR, __VA_ARGS__);                       \
+   }                                                                    \
+                                                                        \
+   static inline struct M_C(base_name, _s) *                            \
+   M_C(name, _as_interface)(M_C(name, _t) obj)                          \
+   {                                                                    \
+     return (struct M_C(base_name, _s) *) obj;                          \
+   }                                                                    \
+                                                                        \
+   M_IF(FUNCOBJI_TEST_METHOD_P(INIT, __VA_ARGS))                        \
+   (                                                                    \
+    static inline void                                                  \
+    M_C(name, _init)(M_C(name, _t) obj)                                 \
+    {                                                                   \
+      obj->callback = M_C(name, _callback);                             \
+      M_MAP(FUNCOBJI_INS_ATTR_INIT, __VA_ARGS__);                       \
+    }                                                                   \
+    , /* END OF INIT METHOD */ )                                        \
+
+
+
+/* Define a numbered type of a parameter of the callback*/
+#define FUNCOBJI_BASE_TYPE(name, num, type)     \
+  typedef type M_C4(name, _param_, num, _t);
+
+/* Define a list of the type of arguments for a function definition */
+#define FUNCOBJI_BASE_ARGLIST(name, num, type)  \
+  M_DEFERRED_COMMA type M_C(param_, num)
+
+/* Define a list of arguments for a function call */
+#define FUNCOBJI_BASE_ARGCALL(name, num, type)  \
+  M_DEFERRED_COMMA M_C(param_, num)
+
+
+/* Helper macros */
+/* arg = (name, type [, oplist]) */
+#define FUNCOBJI_INS_ATTR_STRUCT(arg)                  \
+  M_RET_ARG2 arg M_RET_ARG1 arg;
+
+#define FUNCOBJI_INS_ATTR_LIST(arg)             \
+  M_DEFERRED_COMMA M_RET_ARG2 arg const M_RET_ARG1 arg
+
+#define FUNCOBJI_INS_ATTR_INIT(arg)                                     \
+  M_CALL_INIT(M_RET_ARG3 arg, obj -> M_RET_ARG1 arg);
+
+#define FUNCOBJI_INS_ATTR_INIT_SET(arg)                                 \
+  M_CALL_INIT_SET(M_RET_ARG3 arg, obj -> M_RET_ARG1 arg, M_RET_ARG1 arg);
+
+#define FUNCOBJI_INS_ATTR_CLEAR(arg)                                    \
+  M_CALL_CLEAR(M_RET_ARG3 arg, obj -> M_RET_ARG1 arg);
+
+/* Define the list of arguments of the instance of the callback */
+#define FUNCOBJI_INS_ARGLIST(name, num, param)          \
+  M_DEFERRED_COMMA M_C4(name, _param_, num, _t) param
+
+
+/* Macros for testing for a method presence in all the attributes */
+#define FUNCOBJI_TEST_METHOD2_P(method, op)     \
+  M_TEST_METHOD_P(method, op)
+#define FUNCOBJI_TEST_METHOD1_P(method, arg)                            \
+  M_APPLY(FUNCOBJI_TEST_METHOD2_P, method, M_RET_ARG3 arg)
+#define FUNCOBJI_TEST_METHOD_P(method, ...)                             \
+  M_IF(M_REDUCE2(FUNCOBJI_TEST_METHOD1_P, M_AND, method, __VA_ARGS__))
+
+/* Macro for checking compatible type and oplist for all the attributes */
+#define FUNCOBJI_CONTROL_ALL_OPLIST(name, ...)          \
+  M_MAP2(FUNCOBJI_CONTROL_OPLIST, name, __VA_ARGS__)
+#define FUNCOBJI_CONTROL_OPLIST(name, a)                                \
+  M_CHECK_COMPATIBLE_OPLIST(name, M_RET_ARG1 a, M_RET_ARG2 a, M_RET_ARG3 a)
+
+
+#endif

m-genint.h

@@ -1,7 +1,7 @@
 /*
  * M*LIB - GENINT module
  *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2020, 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:
@@ -22,8 +22,8 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#ifndef __M_GENINT_H
-#define __M_GENINT_H
+#ifndef MSTARLIB_GENINT_H
+#define MSTARLIB_GENINT_H
 
 #include "m-core.h"
 #include "m-atomic.h"
@@ -57,33 +57,43 @@ typedef struct genint_s {
   atomic_ullong *data;       // the bitfield which informs if an integer
 } genint_t[1];
 
+// Define the max supported value
+#define GENINT_MAX_ALLOC (GENINT_LIMBSIZE * (GENINT_LIMBSIZE - GENINT_ABA_CPT))
+
+// Define the size of a limb in bits.
 #define GENINT_LIMBSIZE (sizeof(genint_limb_t) * CHAR_BIT)
 
 #define GENINT_CONTRACT(s)                              do {            \
     assert (s != NULL);                                                 \
-    assert (s->n > 0 && s->n <= GENINT_LIMBSIZE * GENINT_LIMBSIZE);     \
+    assert (s->n > 0 && s->n <= GENINT_MAX_ALLOC);                      \
     assert ((s->max+1) * GENINT_LIMBSIZE >= s->n);                      \
     assert (s->data != NULL);                                           \
   } while (0)
 
 #define GENINT_ONE  ((genint_limb_t)1)
 
+// Value returned in case of error.
+#define GENINT_ERROR (-1U)
+
+// 32 bits of master are kept for handling the ABA problems.
 #define GENINT_ABA_CPT 32
 #define GENINT_ABA_CPT_T uint32_t
 
+// Set the bit i of master
 #define GENINT_MASTER_SET(master, i)                            \
   ((((master)& (~((GENINT_ONE<< GENINT_ABA_CPT)-1))) | (GENINT_ONE << (GENINT_LIMBSIZE - 1 - i))) \
    |((GENINT_ABA_CPT_T)((master) + 1)))
 
+// Reset the bit i of master
 #define GENINT_MASTER_RESET(master, i)                           \
   (((master) & (~((GENINT_ONE<< GENINT_ABA_CPT)-1)) & ~(GENINT_ONE << (GENINT_LIMBSIZE - 1 - i)))       \
    |((GENINT_ABA_CPT_T)((master) + 1)))
 
-static inline void genint_init(genint_t s, size_t n)
+static inline void genint_init(genint_t s, unsigned int n)
 {
-  assert (s != NULL && n > 0 && n <= GENINT_LIMBSIZE * (GENINT_LIMBSIZE - GENINT_ABA_CPT));
+  assert (s != NULL && n > 0 && n <= GENINT_MAX_ALLOC);
   const size_t alloc = (n + GENINT_LIMBSIZE - 1) / GENINT_LIMBSIZE;
-  const size_t index  = n % GENINT_LIMBSIZE;
+  const unsigned int index  = n % GENINT_LIMBSIZE;
   atomic_ullong *ptr = M_MEMORY_REALLOC (atomic_ullong, NULL, alloc);
   if (M_UNLIKELY (ptr == NULL)) {
     M_MEMORY_FULL(alloc);
@@ -95,7 +105,7 @@ static inline void genint_init(genint_t s, size_t n)
   s->mask0 = (index == 0) ? -GENINT_ONE : ~((GENINT_ONE<<(GENINT_LIMBSIZE-index))-1);
   s->mask_master = (((GENINT_ONE << alloc) - 1) << (GENINT_LIMBSIZE-alloc)) >> GENINT_ABA_CPT;
   atomic_init (&s->master, (genint_limb_t)0);
-  for(size_t i = 0; i < alloc; i++)
+  for(unsigned int i = 0; i < alloc; i++)
     atomic_init(&s->data[i], (genint_limb_t)0);
   GENINT_CONTRACT(s);
 }
@@ -113,8 +123,8 @@ static inline size_t genint_size(genint_t s)
   return s->n;
 }
 
-// Typical case: one CAS per pop.
-static inline size_t genint_pop(genint_t s)
+// For a typical case, the amortized cost is one CAS per pop.
+static inline unsigned int genint_pop(genint_t s)
 {
   GENINT_CONTRACT(s);
   // First read master to see which limb is not full.
@@ -122,7 +132,8 @@ static inline size_t genint_pop(genint_t s)
   // While master is not full
   while ((master >> GENINT_ABA_CPT) != s->mask_master) {
     // Let's get the index i of the first not full limb according to master.
-    unsigned int i = m_core_clz(~master);
+    unsigned int i = m_core_clz64(~master);
+    assert (i < GENINT_LIMBSIZE);
     // Let's compute the mask of this limb representing the limb as being full
     genint_limb_t mask = s->mask0;
     mask = (i == s->max) ? mask : -GENINT_ONE;
@@ -133,8 +144,10 @@ static inline size_t genint_pop(genint_t s)
       // If it is now full, we have been preempted by another.
       if (M_UNLIKELY (org == mask))
         goto next_element;
+      assert (org != -GENINT_ONE);
       // At least one bit is free in the limb. Find one.
-      bit = GENINT_LIMBSIZE - 1 - m_core_clz(~org);
+      bit = GENINT_LIMBSIZE - 1 - m_core_clz64(~org);
+      assert (bit < GENINT_LIMBSIZE);
       assert ((org & (GENINT_ONE<<bit)) == 0);
       assert (i * GENINT_LIMBSIZE + GENINT_LIMBSIZE - 1 - bit < s->n);
       // Set the integer as being used.
@@ -165,16 +178,16 @@ static inline size_t genint_pop(genint_t s)
     master = atomic_load(&s->master);
   }
   GENINT_CONTRACT(s);
-  return -(size_t)1; // No more resource available
+  return GENINT_ERROR; // No more resource available
 }
 
-// Typical usage: one CAS per push
-static inline void genint_push(genint_t s, size_t n)
+// For a typical case, the amortized cost is one CAS per pop.
+static inline void genint_push(genint_t s, unsigned int n)
 {
   GENINT_CONTRACT(s);
   assert (n < s->n);
-  const size_t i    = n / GENINT_LIMBSIZE;
-  const size_t bit  = GENINT_LIMBSIZE - 1 - (n % GENINT_LIMBSIZE);
+  const unsigned int i    = n / GENINT_LIMBSIZE;
+  const unsigned int bit  = GENINT_LIMBSIZE - 1 - (n % GENINT_LIMBSIZE);
   genint_limb_t master = atomic_load(&s->master);
   // Load the limb
   genint_limb_t next, org = atomic_load(&s->data[i]);

m-i-list.h

@@ -1,7 +1,7 @@
 /*
  * M*LIB - Intrusive List module
  *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2020, 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:
@@ -22,16 +22,17 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#ifndef __M_I_LIST_H
-#define __M_I_LIST_H
+#ifndef MSTARLIB_I_LIST_H
+#define MSTARLIB_I_LIST_H
 
 #include "m-core.h"
+#include "m-list.h" // For LISTI_ITBASE_DEF
 
-/* Interface to add to a structure to allow intrusive support.
+/* Interface to add to a structure to enable intrusive doubly-linked support.
    name: name of the intrusive list.
    type: name of the type of the structure (aka. struct test_s) - not used currently
    USAGE:
-     struct tmp_str_s {
+     typedef struct tmp_str_s {
       ...
       ILIST_INTERFACE(tmpstr, struct tmp_str_s);
       ...
@@ -40,20 +41,21 @@
 #define ILIST_INTERFACE(name, type)             \
   struct ilist_head_s name
 
-/* Define a list of a given type.
+/* Define a doubly-linked intrusive list of a given type.
+   The type needs to have ILIST_INTERFACE().
    USAGE:
-     LIST_DEF(name, type [, oplist_of_the_type]) */
+     ILIST_DEF(name, type [, oplist_of_the_type]) */
 #define ILIST_DEF(name, ...)                                            \
-  ILISTI_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                                \
-             ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__), M_C(name, _t), M_C(name, _it_t) ), \
-              (name, __VA_ARGS__,                                      M_C(name, _t), M_C(name, _it_t) )))
+  ILISTI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
+                ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name, _t), M_C(name, _it_t) ), \
+                 (name, __VA_ARGS__,                                      M_C(name, _t), M_C(name, _it_t) )))
 
-/* Define the oplist of a ilist of type.
+/* Define the oplist of a doubly-linked instrusive list of type.
    USAGE:
-     LIST_OPLIST(name [, oplist_of_the_type]) */
+     ILIST_OPLIST(name [, oplist_of_the_type]) */
 #define ILIST_OPLIST(...)                                               \
-  ILISTI_OPLIST(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
-                ((__VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__) ),   \
+  ILISTI_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                          \
+                ((__VA_ARGS__, M_DEFAULT_OPLIST),			\
                  (__VA_ARGS__ )))
 
 
@@ -65,15 +67,27 @@ typedef struct ilist_head_s {
   struct ilist_head_s *prev;
 } ilist_head_t;
 
-/* Indirection call to allow expanding all arguments (TBC) */
-#define ILISTI_OPLIST(arg) ILISTI_OPLIST2 arg
+/* Indirection call to allow expanding all arguments */
+#define ILISTI_OPLIST_P1(arg) ILISTI_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define ILISTI_OPLIST_P2(name, oplist)					\
+  M_IF_OPLIST(oplist)(ILISTI_OPLIST_P3, ILISTI_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define ILISTI_OPLIST_FAILURE(name, oplist)		\
+  M_LIB_ERROR(ARGUMENT_OF_ILIST_OPLIST_IS_NOT_AN_OPLIST, name, oplist)
 
 /* Define the oplist of an ilist of type */
-#define ILISTI_OPLIST2(name,oplist)					\
+#define ILISTI_OPLIST_P3(name, oplist)					\
   (INIT(M_C(name, _init)),						\
    CLEAR(M_C(name, _clear)),						\
+   INIT_MOVE(M_C(name, _init_move)),                                    \
+   MOVE(M_C(name, _move)),                                              \
    TYPE(M_C(name,_t)),							\
+   CLEAN(M_C(name,_clean)),                                             \
    SUBTYPE(M_C(name,_type_t)),						\
+   TEST_EMPTY(M_C(name,_empty_p)),                                      \
    IT_TYPE(M_C(name,_it_t)),						\
    IT_FIRST(M_C(name,_it)),						\
    IT_SET(M_C(name,_it_set)),						\
@@ -89,35 +103,54 @@ typedef struct ilist_head_s {
    IT_REMOVE(M_C(name,_remove)),					\
    M_IF_METHOD(NEW, oplist)(IT_INSERT(M_C(name,_insert)),),		\
    OPLIST(oplist),                                                      \
-   PUSH(M_C(name,_push_back)),						\
-   POP(M_C(name,_pop_back))						\
+   SPLICE_BACK(M_C(name,_splice_back))                                  \
    ,M_IF_METHOD(NEW, oplist)(NEW(M_GET_NEW oplist),)                    \
    ,M_IF_METHOD(DEL, oplist)(DEL(M_GET_DEL oplist),)                    \
    )
 
 /* Contract respected by all intrusive lists */
 #define ILISTI_CONTRACT(name, list) do {				\
-    assert (list != NULL);						\
-    assert(list->name.next->prev == &list->name);			\
-    assert(list->name.prev->next == &list->name);			\
+    assert(list != NULL);                                               \
+    assert(list->name.prev != NULL);                                    \
+    assert(list->name.next != NULL);                                    \
+    assert(list->name.next->prev == &list->name);                       \
+    assert(list->name.prev->next == &list->name);                       \
+  } while (0)
+
+#define ILISTI_NODE_CONTRACT(node) do {                                 \
+    assert((node) != NULL);                                             \
+    assert((node)->prev != NULL);                                       \
+    assert((node)->next != NULL);                                       \
+    assert((node)->next->prev == node);                                 \
+    assert((node)->prev->next == node);                                 \
   } while (0)
 
 /* Indirection call to allow expanding all arguments (TBC) */
-#define ILISTI_DEF(arg) ILISTI_DEF2 arg
+#define ILISTI_DEF_P1(arg) ILISTI_DEF_P2 arg
 
-/* Definition of the type and function for an intrusive list.
+/* Validate the oplist before going further */
+#define ILISTI_DEF_P2(name, type, oplist, list_t, it_t)                \
+  M_IF_OPLIST(oplist)(ILISTI_DEF_P3, ILISTI_DEF_FAILURE)(name, type, oplist, list_t, it_t)
+
+/* Stop processing with a compilation failure */
+#define ILISTI_DEF_FAILURE(name, type, oplist, list_t, it_t)   \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(ILIST_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* Definition of the type and function for an intrusive doubly-linked list.
    USAGE:
     name: name of the intrusive list
     type: type of the object
     oplist: oplist of the type
     list_t: type of the intrusive list (name##_t)
-    list_it_t: iterator of the intrusive list (name##_it_t)
+    it_t: iterator of the intrusive list (name##_it_t)
 */
-#define ILISTI_DEF2(name, type, oplist, list_t, list_it_t)              \
+#define ILISTI_DEF_P3(name, type, oplist, list_t, it_t)                 \
 									\
   typedef struct M_C(name, _s) {					\
     struct ilist_head_s name;                                           \
   } list_t[1];                                                          \
+  typedef struct M_C(name, _s) *M_C(name, _ptr);                        \
+  typedef const struct M_C(name, _s) *M_C(name, _srcptr);               \
                                                                         \
   typedef type M_C(name, _type_t);					\
                                                                         \
@@ -126,8 +159,10 @@ typedef struct ilist_head_s {
     struct ilist_head_s *previous;                                      \
     struct ilist_head_s *current;                                       \
     struct ilist_head_s *next;                                          \
-  } list_it_t[1];                                                       \
+  } it_t[1];                                                            \
   									\
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                      \
+                                                                        \
   static inline void M_C(name, _init)(list_t list)			\
   {                                                                     \
     assert (list != NULL);                                              \
@@ -141,14 +176,15 @@ typedef struct ilist_head_s {
     ILISTI_CONTRACT(name, list);					\
     for(struct ilist_head_s *it = list->name.next, *next ;		\
         it != &list->name; it = next) {					\
+      /* Cannot check node contract as previous node may be deleted */  \
       type *obj = M_TYPE_FROM_FIELD(type, it,				\
 				    struct ilist_head_s, name);		\
       /* Read next now before the object is destroyed */		\
       next = it->next;							\
       assert (next != NULL);						\
-      M_GET_CLEAR oplist (*obj);					\
+      M_CALL_CLEAR(oplist, *obj);					\
       /* Delete also the object if a DELETE operand is registered */    \
-      M_IF_METHOD(DEL, oplist)(M_GET_DEL oplist (obj), (void) 0);	\
+      M_IF_METHOD(DEL, oplist)(M_CALL_DEL(oplist, obj), (void) 0);	\
     }									\
     /* Nothing remains in the list anymore */                           \
     list->name.next = &list->name;                                      \
@@ -165,6 +201,29 @@ typedef struct ilist_head_s {
   {                                                                     \
     ILISTI_CONTRACT(name, list);					\
     return list->name.next == &list->name;                              \
+  }                                                                     \
+                                                                        \
+  									\
+  static inline void M_C(name, _init_move)(list_t list, list_t ref)     \
+  {                                                                     \
+    ILISTI_CONTRACT(name, ref);                                         \
+    assert (list != ref);                                               \
+    M_C(name,_init)(list);                                              \
+    if (!M_C(name,_empty_p)(ref)) {                                     \
+      list->name.next = ref->name.next;                                 \
+      list->name.prev = ref->name.prev;                                 \
+      list->name.next->prev = &list->name;                              \
+      list->name.prev->next = &list->name;                              \
+    }                                                                   \
+    ref->name.next = NULL;                                              \
+    ref->name.prev = NULL;                                              \
+    ILISTI_CONTRACT(name, list);					\
+  }                                                                     \
+  									\
+  static inline void M_C(name, _move)(list_t list, list_t ref)          \
+  {                                                                     \
+    M_C(name, _clear)(list);                                            \
+    M_C(name, _init_move)(list, ref);                                   \
   }                                                                     \
                                                                         \
   static inline size_t M_C(name, _size)(const list_t list)		\
@@ -172,8 +231,10 @@ typedef struct ilist_head_s {
     ILISTI_CONTRACT(name, list);					\
     size_t s = 0;                                                       \
     for(const struct ilist_head_s *it = list->name.next ;               \
-        it != &list->name; it = it->next)                               \
+        it != &list->name; it = it->next) {                             \
+      ILISTI_NODE_CONTRACT(it);                                         \
       s++;                                                              \
+    }                                                                   \
     return s;                                                           \
   }                                                                     \
                                                                         \
@@ -249,85 +310,94 @@ typedef struct ilist_head_s {
   }                                                                     \
                                                                         \
   static inline type *							\
-  M_C(name, _next_obj)(const list_t list, const type *obj)		\
+  M_C(name, _next_obj)(const list_t list, type const *obj)		\
   {									\
     ILISTI_CONTRACT(name, list);					\
     assert (obj != NULL);						\
+    ILISTI_NODE_CONTRACT(&obj->name);                                   \
     return obj->name.next == &list->name ? NULL :			\
       M_TYPE_FROM_FIELD(type, obj->name.next,				\
 			struct ilist_head_s, name);			\
   }									\
 									\
   static inline type *							\
-  M_C(name, _previous_obj)(const list_t list, const type *obj)		\
+  M_C(name, _previous_obj)(const list_t list, type const *obj)		\
   {									\
     ILISTI_CONTRACT(name, list);					\
     assert (obj != NULL);						\
+    ILISTI_NODE_CONTRACT(&obj->name);                                   \
     return obj->name.prev == &list->name ? NULL :			\
       M_TYPE_FROM_FIELD(type, obj->name.prev,				\
 			struct ilist_head_s, name);			\
   }									\
 									\
   static inline void                                                    \
-  M_C(name, _it)(list_it_t it, list_t list)				\
+  M_C(name, _it)(it_t it, const list_t list)                            \
   {                                                                     \
     ILISTI_CONTRACT(name, list);					\
     assert (it != NULL);						\
-    it->head = &list->name;                                             \
+    it->head = list->name.next->prev;                                   \
     it->current = list->name.next;                                      \
     it->next = list->name.next->next;                                   \
-    it->previous = &list->name;                                         \
+    it->previous = it->head;                                            \
+    ILISTI_NODE_CONTRACT(it->current);                                  \
   }                                                                     \
                                                                         \
   static inline void                                                    \
-  M_C(name, _it_set)(list_it_t it, const list_it_t cit)			\
+  M_C(name, _it_set)(it_t it, const it_t cit)                           \
   {                                                                     \
     assert (it != NULL && cit != NULL);                                 \
     it->head = cit->head;                                               \
     it->current = cit->current;                                         \
     it->next = cit->next;                                               \
     it->previous = cit->previous;                                       \
+    ILISTI_NODE_CONTRACT(it->current);                                  \
   }                                                                     \
   									\
   static inline void                                                    \
-  M_C(name, _it_last)(list_it_t it, list_t list)			\
+  M_C(name, _it_last)(it_t it, list_t const list)			\
   {                                                                     \
     ILISTI_CONTRACT(name, list);					\
     assert (it != NULL);						\
-    it->head = &list->name;                                             \
+    it->head = list->name.next->prev;                                   \
     it->current = list->name.prev;                                      \
-    it->next = &list->name;                                             \
+    it->next = it->head;                                                \
     it->previous = list->name.prev->prev;                               \
+    ILISTI_NODE_CONTRACT(it->current);                                  \
   }                                                                     \
   									\
   static inline void                                                    \
-  M_C(name, _it_end)(list_it_t it, list_t list)				\
+  M_C(name, _it_end)(it_t it, list_t const list)                        \
   {                                                                     \
     assert (it != NULL && list != NULL);                                \
-    it->head = &list->name;                                             \
-    it->current = &list->name;                                          \
+    it->head = list->name.next->prev;                                   \
+    it->current = it->head;                                             \
     it->next = list->name.next;                                         \
     it->previous = list->name.prev;                                     \
+    ILISTI_NODE_CONTRACT(it->current);                                  \
   }                                                                     \
   									\
   static inline bool                                                    \
-  M_C(name, _end_p)(const list_it_t it)					\
+  M_C(name, _end_p)(const it_t it)					\
   {                                                                     \
     assert (it != NULL);                                                \
+    ILISTI_NODE_CONTRACT(it->current);                                  \
     return it->current == it->head;                                     \
   }                                                                     \
   									\
   static inline bool                                                    \
-  M_C(name, _last_p)(const list_it_t it)				\
+  M_C(name, _last_p)(const it_t it)                                     \
   {                                                                     \
     assert (it != NULL);                                                \
+    ILISTI_NODE_CONTRACT(it->current);                                  \
     return it->next == it->head || it->current == it->head;		\
   }                                                                     \
   									\
   static inline void                                                    \
-  M_C(name, _next)(list_it_t it)					\
+  M_C(name, _next)(it_t it)                                             \
   {                                                                     \
     assert (it != NULL);                                                \
+    /* Cannot check node for it->current: it may have been deleted! */  \
     /* Note: Can't set it->previous to it->current.                     \
        it->current may have been unlinked from the list */              \
     it->current  = it->next;                                            \
@@ -335,12 +405,14 @@ typedef struct ilist_head_s {
     it->next     = it->current->next;                                   \
     it->previous = it->current->prev;                                   \
     assert (it->next != NULL && it->previous != NULL);                  \
+    ILISTI_NODE_CONTRACT(it->current);                                  \
   }                                                                     \
                                                                         \
   static inline void                                                    \
-  M_C(name, _previous)(list_it_t it)					\
+  M_C(name, _previous)(it_t it)                                         \
   {                                                                     \
     assert (it != NULL);                                                \
+    /* Cannot check node for it->current: it may have been deleted! */  \
     /* Note: Can't set it->next to it->current.                         \
        it->current may have been unlinked from the list */              \
     it->current  = it->previous;                                        \
@@ -348,10 +420,11 @@ typedef struct ilist_head_s {
     it->next     = it->current->next;                                   \
     it->previous = it->current->prev;                                   \
     assert (it->next != NULL && it->previous != NULL);                  \
+    ILISTI_NODE_CONTRACT(it->current);                                  \
   }                                                                     \
   									\
   static inline bool                                                    \
-  M_C(name, _it_equal_p)(const list_it_t it1, const list_it_t it2 )	\
+  M_C(name, _it_equal_p)(const it_t it1, const it_t it2 )               \
   {                                                                     \
     assert (it1 != NULL && it2 != NULL);                                \
     /* No need to check for next & previous */                          \
@@ -359,9 +432,10 @@ typedef struct ilist_head_s {
   }                                                                     \
   									\
   static inline type *                                                  \
-  M_C(name, _ref)(const list_it_t it)					\
+  M_C(name, _ref)(const it_t it)					\
   {                                                                     \
     assert (it != NULL && it->current != NULL);                         \
+    ILISTI_NODE_CONTRACT(it->current);                                  \
     /* check if 'it' was not deleted */                                 \
     assert (it->current->next == it->next);                             \
     assert (it->current->prev == it->previous);                         \
@@ -370,37 +444,39 @@ typedef struct ilist_head_s {
 			     struct ilist_head_s, name);		\
   }                                                                     \
   									\
-  static inline const type *                                            \
-  M_C(name, _cref)(const list_it_t it)					\
+  static inline type const *                                            \
+  M_C(name, _cref)(const it_t it)					\
   {                                                                     \
     type *ptr = M_C(name, _ref)(it);					\
     return M_CONST_CAST(type, ptr);                                     \
   }                                                                     \
   									\
   static inline void							\
-  M_C(name, _remove)(list_t list, list_it_t it)				\
+  M_C(name, _remove)(list_t list, it_t it)				\
   {                                                                     \
     ILISTI_CONTRACT(name, list);					\
+    ILISTI_NODE_CONTRACT(it->current);                                  \
     (void)list;	/* list param is not used */				\
     type *obj = M_TYPE_FROM_FIELD(type, it->current,			\
 				  struct ilist_head_s, name);		\
     M_C(name, _unlink)(obj);						\
-    M_GET_CLEAR oplist (obj);						\
-    M_IF_METHOD(DEL, oplist)(M_GET_DEL oplist (obj), (void) 0);		\
+    M_CALL_CLEAR(oplist, obj);						\
+    M_IF_METHOD(DEL, oplist)(M_CALL_DEL(oplist, obj), (void) 0);        \
     M_C(name, _next)(it);						\
   }									\
 									\
   M_IF_METHOD(NEW, oplist)(						\
   static inline void							\
-  M_C(name, _insert)(list_t list, list_it_t it, type x)			\
+  M_C(name, _insert)(list_t list, it_t it, type x)			\
   {                                                                     \
     ILISTI_CONTRACT(name, list);					\
-    type *p = M_GET_NEW oplist (type);					\
+    ILISTI_NODE_CONTRACT(it->current);                                  \
+    type *p = M_CALL_NEW(oplist, type);                                 \
     if (M_UNLIKELY (p == NULL)) {					\
       M_MEMORY_FULL (sizeof (type));					\
       return ;								\
     }									\
-    M_GET_INIT_SET oplist (*p, x);					\
+    M_CALL_INIT_SET(oplist, *p, x);					\
     type *obj = M_C(name, _ref)(it);					\
     M_C(name, _push_after)(obj, p);					\
     (void) list;							\
@@ -448,30 +524,89 @@ typedef struct ilist_head_s {
   }									\
 									\
   static inline void                                                    \
-  M_C(name, _splice_back)(list_t nv, list_t ov, list_it_t it)		\
+  M_C(name, _splice_back)(list_t nv, list_t ov, it_t it)		\
   {                                                                     \
     ILISTI_CONTRACT(name, nv);						\
     ILISTI_CONTRACT(name, ov);						\
+    ILISTI_NODE_CONTRACT(it->current);                                  \
     assert (it != NULL);						\
     (void) ov;								\
     type *obj = M_C(name, _ref)(it);					\
     M_C(name, _unlink)(obj);						\
     M_C(name, _push_back)(nv, obj);					\
+    M_C(name, _next)(it);                                               \
     ILISTI_CONTRACT(name, nv);						\
     ILISTI_CONTRACT(name, ov);						\
   }									\
 									\
   static inline void							\
+  M_C(name, _splice_at)(list_t nlist, it_t npos,                        \
+                        list_t olist, it_t opos)                        \
+  {                                                                     \
+    ILISTI_CONTRACT(name, nlist);					\
+    ILISTI_CONTRACT(name, olist);					\
+    assert (npos != NULL && opos != NULL);                              \
+    assert (!M_C(name, _end_p)(opos));					\
+    /* npos may be end */                                               \
+    (void) olist, (void) nlist;                                         \
+    type *obj = M_C(name, _ref)(opos);					\
+    struct ilist_head_s *ref = npos->current;                           \
+    /* Remove object */                                                 \
+    M_C(name, _unlink)(obj);						\
+    /* Push 'obj' after 'ref' */                                        \
+    struct ilist_head_s *next = ref->next;                              \
+    ref->next = &obj->name;                                             \
+    obj->name.next = next;                                              \
+    obj->name.prev = ref;                                               \
+    next->prev = &obj->name;                                            \
+    /* Move iterator in old list */                                     \
+    M_C(name, _next)(opos);                                             \
+    /* Set npos iterator to new position of object */                   \
+    npos->previous = ref;                                               \
+    npos->current = &obj->name;                                         \
+    npos->next = next;                                                  \
+    ILISTI_CONTRACT(name, nlist);					\
+    ILISTI_CONTRACT(name, olist);					\
+  }									\
+									\
+  static inline void							\
   M_C(name, _swap)(list_t d, list_t e)					\
   {									\
     ILISTI_CONTRACT(name, d);						\
     ILISTI_CONTRACT(name, e);						\
-    M_SWAP(struct ilist_head_s *, d->name.next, e->name.next);		\
-    M_SWAP(struct ilist_head_s *, d->name.prev, e->name.prev);		\
-    M_SWAP(struct ilist_head_s *, d->name.next->prev, e->name.next->prev); \
-    M_SWAP(struct ilist_head_s *, d->name.prev->next, e->name.prev->next); \
+    struct ilist_head_s *d_item = d->name.next;                         \
+    struct ilist_head_s *e_item = e->name.next;                         \
+    d->name.next = e_item == &e->name ? &d->name : e_item;              \
+    e->name.next = d_item == &d->name ? &e->name : d_item;              \
+    d_item = d->name.prev;                                              \
+    e_item = e->name.prev;                                              \
+    d->name.prev = e_item == &e->name ? &d->name : e_item;              \
+    e->name.prev = d_item == &d->name ? &e->name : d_item;              \
+    d->name.next->prev = &d->name;                                      \
+    d->name.prev->next = &d->name;                                      \
+    e->name.next->prev = &e->name;                                      \
+    e->name.prev->next = &e->name;                                      \
     ILISTI_CONTRACT(name, d);						\
     ILISTI_CONTRACT(name, e);						\
   }									\
-  
+									\
+  static inline void							\
+  M_C(name, _reverse)(list_t list)                                      \
+  {									\
+    ILISTI_CONTRACT(name, list);                                        \
+    struct ilist_head_s *next, *it;                                     \
+    for(it = list->name.next ; it != &list->name; it = next) {          \
+      next = it->next;                                                  \
+      it->next = it->prev;                                              \
+      it->prev = next;                                                  \
+    }                                                                   \
+    next = it->next;                                                    \
+    it->next = it->prev;                                                \
+    it->prev = next;                                                    \
+    ILISTI_CONTRACT(name, list);                                        \
+  }									\
+                                                                        \
+  LISTI_ITBASE_DEF(name, type, oplist, list_t, it_t)
+
+
 #endif

m-i-shared.h

@@ -1,7 +1,7 @@
 /*
  * M*LIB - INTRUSIVE SHARED PTR Module
  *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2020, 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:
@@ -22,8 +22,8 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#ifndef __M_I_SHARED_PTR__H
-#define __M_I_SHARED_PTR__H
+#ifndef MSTARLIB_I_SHARED_PTR_H
+#define MSTARLIB_I_SHARED_PTR_H
 
 #include "m-core.h"
 #include "m-atomic.h"
@@ -31,9 +31,9 @@
 /* Define the oplist of a intrusive shared pointer.
    USAGE: ISHARED_OPLIST(name [, oplist_of_the_type]) */
 #define ISHARED_PTR_OPLIST(...)                                      \
-  ISHAREDI_PTR_OPLIST(M_IF_NARGS_EQ1(__VA_ARGS__)                    \
-                      ((__VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__) ),             \
-                       (__VA_ARGS__ )))
+  ISHAREDI_PTR_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                 \
+                         ((__VA_ARGS__, M_DEFAULT_OPLIST),           \
+                          (__VA_ARGS__ )))
 
 /* Interface to add to a structure to allow intrusive support.
    name: name of the intrusive shared pointer.
@@ -42,25 +42,36 @@
 #define ISHARED_PTR_INTERFACE(name, type)       \
   atomic_int M_C(name, _cpt)
 
+
 /* Define the intrusive shared pointer type and its static inline functions.
-   USAGE: ISHARED_PTR_DEF(name[, oplist]) */
+   USAGE: ISHARED_PTR_DEF(name, type, [, oplist]) */
 #define ISHARED_PTR_DEF(name, ...)                                      \
-  ISHAREDI_PTR_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                          \
-                   ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__) ), \
-                    (name, __VA_ARGS__ )))
+  ISHAREDI_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                       \
+                      ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)() ), \
+                       (name, __VA_ARGS__ )))
 
 
 /********************************** INTERNAL ************************************/
 
-#define ISHAREDI_PTR_OPLIST(arg) ISHAREDI_PTR_OPLIST2 arg
+// Deferred evaluation
+#define ISHAREDI_PTR_OPLIST_P1(arg) ISHAREDI_PTR_OPLIST_P2 arg
 
-#define ISHAREDI_PTR_OPLIST2(name, oplist) (                            \
+/* Validation of the given oplist */
+#define ISHAREDI_PTR_OPLIST_P2(name, oplist)				\
+  M_IF_OPLIST(oplist)(ISHAREDI_PTR_OPLIST_P3, ISHAREDI_PTR_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define ISHAREDI_PTR_OPLIST_FAILURE(name, oplist)			\
+  M_LIB_ERROR(ARGUMENT_OF_ISHARED_PTR_OPLIST_IS_NOT_AN_OPLIST, name, oplist)
+
+// Define the oplist
+#define ISHAREDI_PTR_OPLIST_P3(name, oplist) (                          \
   INIT(M_INIT_DEFAULT),                                                 \
   INIT_SET(M_C(name, _init_set2) M_IPTR),				\
   SET(M_C(name, _set) M_IPTR),						\
   CLEAR(M_C(name, _clear)),						\
   CLEAN(M_C(name, _clean) M_IPTR),					\
-  TYPE(M_C(name, _type_t)),						\
+  TYPE(M_C(name, _t)),                                                  \
   OPLIST(oplist),                                                       \
   SUBTYPE(M_C(name, _type_t))						\
   ,M_IF_METHOD(NEW, oplist)(NEW(M_GET_NEW oplist),)                     \
@@ -68,13 +79,24 @@
   ,M_IF_METHOD(DEL, oplist)(DEL(M_GET_DEL oplist),)                     \
   )
 
-#define ISHAREDI_PTR_DEF(arg) ISHAREDI_PTR_DEF2 arg
+// Deferred evaluatioin
+#define ISHAREDI_PTR_DEF_P1(arg) ISHAREDI_PTR_DEF_P2 arg
 
-#define ISHAREDI_PTR_DEF2(name, type, oplist)                           \
+/* Validate the oplist before going further */
+#define ISHAREDI_PTR_DEF_P2(name, type, oplist)                         \
+  M_IF_OPLIST(oplist)(ISHAREDI_PTR_DEF_P3, ISHAREDI_PTR_DEF_FAILURE)(name, type, oplist)
+
+/* Stop processing with a compilation failure */
+#define ISHAREDI_PTR_DEF_FAILURE(name, type, oplist)   \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(ISHARED_PTR_DEF): the given argument is not a valid oplist: " #oplist)
+
+#define ISHAREDI_PTR_DEF_P3(name, type, oplist)                         \
                                                                         \
   typedef type *M_C(name,_t);						\
   typedef type M_C(name, _type_t);					\
                                                                         \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                      \
+                                                                        \
   static inline M_C(name,_t)                                            \
   M_C(name, _init)(type *ptr)						\
   {									\
@@ -100,26 +122,28 @@
     *ptr = M_C(name, _init_set)(shared);				\
   }									\
   									\
+  M_IF_METHOD2(INIT, NEW, oplist)(					\
   static inline M_C(name,_t)                                            \
   M_C(name, _init_new)(void)                                            \
   {									\
-    type *ptr = M_GET_NEW oplist (type);                                \
+    type *ptr = M_CALL_NEW(oplist, type);                               \
     if (ptr == NULL) {                                                  \
       M_MEMORY_FULL(sizeof(type));                                      \
       return NULL;                                                      \
     }                                                                   \
-    M_GET_INIT oplist (*ptr);                                           \
+    M_CALL_INIT(oplist, *ptr);                                          \
     atomic_init (&ptr->M_C(name, _cpt), 1);                             \
     return ptr;                                                         \
   }									\
+  , /* End of INIT/NEW */)						\
   									\
   static inline void				                        \
   M_C(name, _clear)(M_C(name,_t) shared)                                \
   {									\
     if (shared != NULL)	{						\
       if (atomic_fetch_sub(&(shared->M_C(name, _cpt)), 1) == 1)	{       \
-        M_GET_CLEAR oplist (*shared);                                   \
-        M_IF_DISABLED_METHOD(DEL, oplist)(, M_GET_DEL oplist (shared);) \
+        M_CALL_CLEAR(oplist, *shared);                                  \
+        M_IF_DISABLED_METHOD(DEL, oplist)(, M_CALL_DEL(oplist, shared);) \
       }									\
     }                                                                   \
   }									\

m-mempool.h

@@ -1,7 +1,7 @@
 /*
  * M*LIB - MEMPOOL module
  *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2020, 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:
@@ -22,12 +22,12 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#ifndef __M_MEMPOOL_H
-#define __M_MEMPOOL_H
+#ifndef MSTARLIB_MEMPOOL_H
+#define MSTARLIB_MEMPOOL_H
 
 #include "m-core.h"
 
-/* Fast Fixed Size thread unsafe allocator.
+/* Fast Fixed Size thread unsafe allocator based on memory region.
    USAGE:
      MEMPOOL_DEF(memppol_uint, unsigned int)
      ...
@@ -50,7 +50,7 @@
   typedef struct M_C(name,_segment_s) {					\
     unsigned int count;                                                 \
     struct M_C(name,_segment_s) *next;					\
-    M_C(name,_union_t)	tab[MEMPOOLI_MAX_PER_SEGMENT(type)];		\
+    M_C(name,_union_t)	tab[MEMPOOL_MAX_PER_SEGMENT(type)];		\
   } M_C(name,_segment_t);						\
   									\
   typedef struct M_C(name, _s) {					\
@@ -99,7 +99,7 @@
     M_C(name,_segment_t) *segment = mem->current_segment;		\
     assert(segment != NULL);                                            \
     unsigned int count = segment->count;                                \
-    if (M_UNLIKELY (count >= MEMPOOLI_MAX_PER_SEGMENT(type))) {		\
+    if (M_UNLIKELY (count >= MEMPOOL_MAX_PER_SEGMENT(type))) {		\
       M_C(name,_segment_t) *new_segment = M_MEMORY_ALLOC (M_C(name,_segment_t)); \
       if (M_UNLIKELY (new_segment == NULL)) {				\
         M_MEMORY_FULL(sizeof (M_C(name,_segment_t)));			\
@@ -129,17 +129,21 @@
     MEMPOOLI_CONTRACT(mem, type);                                       \
   }                                                                     \
 
+/* User shall be able to cutomize the size of the segment and/or
+   the minimun number of elements.
+*/
+#ifndef MEMPOOL_MAX_PER_SEGMENT
+#define MEMPOOL_MAX_PER_SEGMENT(type)					\
+  M_MAX((16*1024-sizeof(unsigned int) - 2*sizeof(void*)) / sizeof (type), 256U)
+#endif
+
 /********************************** INTERNAL ************************************/
 
-// TODO: user shall be able to cutomize the size of the segment and/or
-// the minimun number of elements... i.e. all the formula!
-#define MEMPOOLI_MAX_PER_SEGMENT(type)					\
-  M_MAX((16*1024-sizeof(unsigned int) - 2*sizeof(void*)) / sizeof (type), 256U)
 
 #define MEMPOOLI_CONTRACT(mempool, type) do {                           \
     assert((mempool) != NULL);                                          \
     assert((mempool)->current_segment != NULL);                         \
-    assert((mempool)->current_segment->count <= MEMPOOLI_MAX_PER_SEGMENT(type)); \
+    assert((mempool)->current_segment->count <= MEMPOOL_MAX_PER_SEGMENT(type)); \
   } while (0)
 
 #endif

m-mutex.h

@@ -1,7 +1,7 @@
 /*
  * M*LIB - Thin Mutex & Thread wrapper
  *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2020, 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:
@@ -22,12 +22,8 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#ifndef __M_MUTEX_H
-#define __M_MUTEX_H
-
-#include <assert.h>
-#include <stdbool.h>
-#include "m-core.h"
+#ifndef MSTARLIB_MUTEX_H
+#define MSTARLIB_MUTEX_H
 
 #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L    \
   && !defined(__STDC_NO_THREADS__)
@@ -35,249 +31,374 @@
 /****************************** C11 version ********************************/
 
 #include <threads.h>
+#include <assert.h>
+#include <stdbool.h>
+#include "m-core.h"
 
+/* Define a mutex type based on C11 definition */
 typedef mtx_t                  m_mutex_t[1];
+
+/* Define a condition variable type based on C11 definition */
 typedef cnd_t                  m_cond_t[1];
+
+/* Define a thread type based on C11 definition */
 typedef thrd_t                 m_thread_t[1];
 
+/* Initialize the mutex (constructor) */
 static inline void m_mutex_init(m_mutex_t m)
 {
   int rc = mtx_init(m, mtx_plain);
-  M_ASSERT_INIT (rc == 0);
+  // Abort program in case of initialization failure
+  // There is really nothing else to do if a mutex cannot be constructed
+  M_ASSERT_INIT (rc == 0, "mutex");
 }
 
+/* Clear the mutex (destructor) */
 static inline void m_mutex_clear(m_mutex_t m)
 {
   mtx_destroy(m);
 }
 
+/* Lock the mutex */
 static inline void m_mutex_lock(m_mutex_t m)
 {
   mtx_lock(m);
 }
 
+/* Unlock the mutex */
 static inline void m_mutex_unlock(m_mutex_t m)
 {
   mtx_unlock(m);
 }
 
+/* Initialize the condition variable (constructor) */
 static inline void m_cond_init(m_cond_t c)
 {
   int rc = cnd_init(c);
-  M_ASSERT_INIT (rc == 0);
+  // Abort program in case of initialization failure
+  // There is really nothing else to do if the object cannot be constructed
+  M_ASSERT_INIT (rc == 0, "conditional variable");
 }
 
+/* Clear the condition variable (destructor) */
 static inline void m_cond_clear(m_cond_t c)
 {
   cnd_destroy(c);
 }
 
-static inline void m_cond_clear(m_cond_t c)
-{
-  cnd_signal(c);
-}
-
+/* Signal the condition variable to at least one waiting thread */
 static inline void m_cond_signal(m_cond_t c)
 {
   cnd_signal(c);
 }
 
+/* Signal the condition variable to all waiting threads */
 static inline void m_cond_broadcast(m_cond_t c)
 {
   cnd_broadcast(c);
 }
 
+/* Wait for signaling the condition variable by another thread */
 static inline void m_cond_wait(m_cond_t c, m_mutex_t m)
 {
   cnd_wait(c, m);
 }
 
+/* Create the thread (constructor) and start it */
 static inline void m_thread_create(m_thread_t t, void (*func)(void*), void* arg)
 {
-  int rc = thrd_create(t, ((int)(*)(void*))func, arg);
-  M_ASSERT_INIT (rc == thrd_success);
+  int rc = thrd_create(t, (int(*)(void*))(void(*)(void))func, arg);
+  // Abort program in case of initialization failure
+  M_ASSERT_INIT (rc == thrd_success, "thread");
 }
 
+/* Wait for the thread to terminate and destroy it (destructor) */
 static inline void m_thread_join(m_thread_t t)
 {
-  int rc = thrd_join(t, NULL);
+  int rc = thrd_join(*t, NULL);
   assert (rc == thrd_success);
+  // Avoid warning about variable unused.
+  (void) rc;
+}
+
+/* The thread has nothing meaningfull to do.
+   Inform the OS to let other threads be scheduled */
+static inline void m_thread_yield(void)
+{
+  thrd_yield();
+}
+
+/* Sleep the thread for at least usec microseconds.
+   Return true if the sleep was successful */
+static inline bool m_thread_sleep(unsigned long long usec)
+{
+  struct timespec tv;
+  tv.tv_sec = usec / 1000000ULL;
+  tv.tv_nsec = (usec % 1000000ULL) * 1000UL;
+  int retval = thrd_sleep(&tv, NULL);
+  return retval == 0;
 }
 
 // Internal type, not exported.
 typedef once_flag                     m_oncei_t[1];
+
+// Initial value for m_oncei_t
 #define M_ONCEI_INIT_VALUE            { ONCE_FLAG_INIT }
+
+// Call the function exactly once
 static inline void m_oncei_call(m_oncei_t o, void (*func)(void))
 {
   call_once(o,func);
 }
 
+// Attribute to use to allocate a global variable to a thread.
+#define M_THREAD_ATTR _Thread_local
 
 
-
-#elif defined(WIN32) || defined(_WIN32)
+// MSYS2 doesn't define _WIN32 by default.
+#elif defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__)
 
 /****************************** WIN32 version ******************************/
 
+/* CriticalSection & ConditionVariable are available from Windows Vista */
+#ifndef WINVER
+#define WINVER        _WIN32_WINNT_VISTA
+#endif
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT  _WIN32_WINNT_VISTA
+#endif
 #include <windows.h>
+#include <assert.h>
+#include <stdbool.h>
+#include "m-core.h"
 
-typedef HANDLE                 m_mutex_t[1];
-typedef HANDLE                 m_cond_t[1];
+/* Define a thread type based on WINDOWS definition */
 typedef HANDLE                 m_thread_t[1];
 
+/* Define a mutex type based on WINDOWS definition */
+typedef CRITICAL_SECTION       m_mutex_t[1];
+
+/* Define a condition variable type based on WINDOWS definition */
+typedef CONDITION_VARIABLE     m_cond_t[1];
+
+/* Initialize a mutex (Constructor)*/
 static inline void m_mutex_init(m_mutex_t m)
 {
-  *m = CreateMutex(NULL, FALSE, NULL);
-  M_ASSERT_INIT(*m != NULL);
+  InitializeCriticalSection(m);
 }
 
+/* Clear a mutex (destructor) */
 static inline void m_mutex_clear(m_mutex_t m)
 {
-  CloseHandle(*m);
+  DeleteCriticalSection(m);
 }
 
+/* Lock a mutex */
 static inline void m_mutex_lock(m_mutex_t m)
 {
-  DWORD dwWaitResult = WaitForSingleObject(*m, INFINITE);
-  assert (dwWaitResult == WAIT_OBJECT_0);
+  EnterCriticalSection(m);
 }
 
+/* Unlock a mutex */
 static inline void m_mutex_unlock(m_mutex_t m)
 {
-  ReleaseMutex(*m);
+  LeaveCriticalSection(m);
 }
 
-// Internal function, not exported
-#define M_MUTEXI_INIT_VALUE      { NULL }
-static inline void m_mutexi_lazy_lock (m_mutex_t m)
-{
-  HANDLE *addr = m;
-  if (*addr == NULL) {
-    /* Try to create one, affect it atomicaly and otherwise clears it */
-    HANDLE h = CreateMutex(NULL, FALSE, NULL);
-    if (InterlockedCompareExchangePointer((PVOID*)addr, (PVOID)h, NULL) != NULL)
-      CloseHandle(h);
-    /* FIXME: there is no way to clean the mutex at program exit... */
-  }
-  DWORD dwWaitResult = WaitForSingleObject(*addr, INFINITE);
-  assert (dwWaitResult == WAIT_OBJECT_0);
-}
-
-// TODO: Use cond var described here
-// https://msdn.microsoft.com/en-us/library/windows/desktop/ms682052(v=vs.85).aspx
+/* Initialize a condition variable (constructor) */
 static inline void m_cond_init(m_cond_t c)
 {
-  *c = CreateEvent (NULL,  FALSE, FALSE, NULL);
-  M_ASSERT_INIT (*c != NULL);
+  InitializeConditionVariable(c);
 }
 
+/* Clear a condition variable (destructor) */
 static inline void m_cond_clear(m_cond_t c)
 {
-  CloseHandle(*c);
+  (void) c; // There is no destructor for this object.
 }
 
+/* Signal a condition variable to at least one waiting thread */
 static inline void m_cond_signal(m_cond_t c)
 {
-  PulseEvent(*c);
+  WakeConditionVariable(c);
 }
 
+/* Signal a condition variable to all waiting threads */
 static inline void m_cond_broadcast(m_cond_t c)
 {
-  PulseEvent(*c);
+  WakeAllConditionVariable(c);
 }
 
+/* Wait for a condition variable */
 static inline void m_cond_wait(m_cond_t c, m_mutex_t m)
 {
-  DWORD dwWaitResult = SignalObjectAndWait(*m, *c, INFINITE,FALSE);
-  assert (dwWaitResult == WAIT_OBJECT_0);
-  dwWaitResult = WaitForSingleObject(*m, INFINITE);
-  assert (dwWaitResult == WAIT_OBJECT_0);
+  SleepConditionVariableCS(c, m, INFINITE);
 }
 
+/* Create a thread (constructor) and start it */
 static inline void m_thread_create(m_thread_t t, void (*func)(void*), void *arg)
 {
-  *t = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) func, arg, 0, NULL);
-  M_ASSERT_INIT (*t != NULL);
+  *t = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) (uintptr_t) func, arg, 0, NULL);
+  M_ASSERT_INIT (*t != NULL, "thread");
 }
 
+/* Wait for the thread to terminate and destroy it (destructor) */
 static inline void m_thread_join(m_thread_t t)
 {
   DWORD dwWaitResult = WaitForSingleObject(*t, INFINITE);
+  (void) dwWaitResult;
   assert (dwWaitResult == WAIT_OBJECT_0);
+  CloseHandle(*t);
+}
+
+/* The thread has nothing meaningfull to do.
+   Inform the OS to let other threads be scheduled */
+static inline void m_thread_yield(void)
+{
+  Sleep(0);
+}
+
+/* Sleep the thread for at least usec microseconds
+   Return true if the sleep was successful */
+static inline bool m_thread_sleep(unsigned long long usec)
+{
+  LARGE_INTEGER ft;
+  ft.QuadPart = -(10ULL*usec);
+  HANDLE hd = CreateWaitableTimer(NULL, TRUE, NULL);
+  M_ASSERT_INIT (hd != NULL, "timer");
+  SetWaitableTimer(hd, &ft, 0, NULL, NULL, 0);
+  DWORD dwWaitResult = WaitForSingleObject(hd, INFINITE);
+  CloseHandle(hd);
+  return dwWaitResult == WAIT_OBJECT_0;
 }
 
 
+// Internal type, not exported.
+typedef INIT_ONCE                     m_oncei_t[1];
+#define M_ONCEI_INIT_VALUE            { INIT_ONCE_STATIC_INIT }
+static inline BOOL CALLBACK m_oncei_callback( PINIT_ONCE InitOnce, PVOID Parameter, PVOID *lpContext)
+{
+    void (*func)(void);
+    (void) InitOnce;
+    (void) lpContext;
+    func = (void (*)(void))(uintptr_t) Parameter;
+    (*func)();
+    return TRUE;
+}
+static inline void m_oncei_call(m_oncei_t o, void (*func)(void))
+{
+  InitOnceExecuteOnce(o, m_oncei_callback, (void*)(intptr_t)func, NULL);
+}
 
+#if defined(_MSC_VER)
+// Attribute to use to allocate a global variable to a thread (MSVC def).
+# define M_THREAD_ATTR __declspec( thread )
+#else
+// Attribute to use to allocate a global variable to a thread (GCC def).
+# define M_THREAD_ATTR __thread
+#endif
 
 #else
 
 /**************************** PTHREAD version ******************************/
 
 #include <pthread.h>
+#ifdef _POSIX_PRIORITY_SCHEDULING
+#include <sched.h>
+#endif
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <assert.h>
+#include <stdbool.h>
+#include "m-core.h"
 
+/* Define a mutex type based on PTHREAD definition */
 typedef pthread_mutex_t        m_mutex_t[1];
+
+/* Define a condition variable type based on PTHREAD definition */
 typedef pthread_cond_t         m_cond_t[1];
+
+/* Define a thread type based on PTHREAD definition */
 typedef pthread_t              m_thread_t[1];
 
+/* Initialize the mutex (constructor) */
 static inline void m_mutex_init(m_mutex_t m)
 {
   int _rc = pthread_mutex_init(m, NULL);
-  M_ASSERT_INIT (_rc == 0);
+  // Abort program in case of initialization failure
+  // There is really nothing else to do if a mutex cannot be constructed
+  M_ASSERT_INIT (_rc == 0, "mutex");
 }
 
+/* Clear the mutex (destructor) */
 static inline void m_mutex_clear(m_mutex_t m)
 {
   pthread_mutex_destroy(m);
 }
 
+/* Lock the mutex */
 static inline void m_mutex_lock(m_mutex_t m)
 {
   pthread_mutex_lock(m);
 }
 
+/* Unlock the mutex */
 static inline void m_mutex_unlock(m_mutex_t m)
 {
   pthread_mutex_unlock(m);
 }
 
+/* Lazy lock initialization */
 #define M_MUTEXI_INIT_VALUE    { PTHREAD_MUTEX_INITIALIZER }
+
+/* Internal function compatible with lazy lock */
 static inline void m_mutexi_lazy_lock(m_mutex_t m)
 {
   pthread_mutex_lock(m);
 }
 
+/* Initialize the condition variable (constructor) */
 static inline void m_cond_init(m_cond_t c)
 {
   int _rc = pthread_cond_init(c, NULL);
-  M_ASSERT_INIT (_rc == 0);
+  // Abort program in case of initialization failure
+  // There is really nothing else to do if a mutex cannot be constructed
+  M_ASSERT_INIT (_rc == 0, "conditional variable");
 }
 
+/* Clear the condition variable (destructor) */
 static inline void m_cond_clear(m_cond_t c)
 {
   pthread_cond_destroy(c);
 }
 
+/* Signal a condition variable to at least a waiting thread */
 static inline void m_cond_signal(m_cond_t c)
 {
   pthread_cond_signal(c);
 }
 
+/* Signal a condition variable to all waiting threads */
 static inline void m_cond_broadcast(m_cond_t c)
 {
   pthread_cond_broadcast(c);
 }
 
+/* Waiting for a condition variable */
 static inline void m_cond_wait(m_cond_t c, m_mutex_t m)
 {
   pthread_cond_wait(c, m);
 }
 
+/* Create a thread (constructor) and start it */
 static inline void m_thread_create(m_thread_t t, void (*func)(void*), void *arg)
 {
-  int _rc = pthread_create(t, NULL, (void*(*)(void*))func, arg);
-  M_ASSERT_INIT (_rc == 0);
+  int _rc = pthread_create(t, NULL, (void*(*)(void*))(void(*)(void))func, arg);
+  M_ASSERT_INIT (_rc == 0, "thread");
 }
 
+/* Wait for the thread to terminate and destroy it (destructor) */
 static inline void m_thread_join(m_thread_t t)
 {
   int _rc = pthread_join(*t, NULL);
@@ -285,6 +406,28 @@ static inline void m_thread_join(m_thread_t t)
   assert (_rc == 0);
 }
 
+/* The thread has nothing meaningfull to do.
+   Inform the OS to let other threads be scheduled */
+static inline void m_thread_yield(void)
+{
+#ifdef _POSIX_PRIORITY_SCHEDULING
+  sched_yield();
+#endif
+}
+
+/* Sleep for at least usec microseconds
+   Return true if the sleep was successful */
+static inline bool m_thread_sleep(unsigned long long usec)
+{
+  struct timeval tv;
+  /* We don't want to use usleep or nanosleep so that
+     we remain compatible with strict C99 build */
+  tv.tv_sec = usec / 1000000ULL;
+  tv.tv_usec = usec % 1000000ULL;
+  int retval = select(1, NULL, NULL, NULL, &tv);
+  return retval == 0;
+}
+
 // Internal type, not exported.
 typedef pthread_once_t                m_oncei_t[1];
 #define M_ONCEI_INIT_VALUE            { PTHREAD_ONCE_INIT }
@@ -293,8 +436,13 @@ static inline void m_oncei_call(m_oncei_t o, void (*func)(void))
   pthread_once(o,func);
 }
 
+#define M_THREAD_ATTR __thread
+
 #endif
 
+// TODO: m_thread_sleep doesn't yield thread during waiting, making it a poor choice for active waiting.
+// TODO: Obsolete M_LOCK macro.
+
 /* M_LOCK macro. Allow simple locking encapsulation.
    USAGE:
     static M_LOCK_DECL(name);

m-prioqueue.h

@@ -1,7 +1,7 @@
 /*
  * M*LIB - dynamic priority queue module
  *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2020, 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:
@@ -22,37 +22,50 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#ifndef __M_PRIOQUEUE_H
-#define __M_PRIOQUEUE_H
+#ifndef MSTARLIB_PRIOQUEUE_H
+#define MSTARLIB_PRIOQUEUE_H
 
 #include "m-core.h"
 #include "m-array.h"
 
 /* Priority queue based on binary heap implementation */
 
-/* Define an prioqueue of a given type.
+/* Define a prioqueue of a given type and its associated functions.
    USAGE: PRIOQUEUE_DEF(name, type [, oplist_of_the_type]) */
 #define PRIOQUEUE_DEF(name, ...)                                            \
-  PRIOQUEUEI_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                                \
-  ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__), M_C(name,_t), M_C(name,_it_t) ), \
-   (name, __VA_ARGS__,                                      M_C(name,_t), M_C(name,_it_t))))
+  PRIOQUEUEI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                         \
+                    ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name,_t), M_C(name,_it_t) ), \
+                     (name, __VA_ARGS__,                                        M_C(name,_t), M_C(name,_it_t))))
 
-/* Define the oplist of an prioqueue of type.
+
+/* Define the oplist of a prioqueue of type.
    USAGE: PRIOQUEUE_OPLIST(name[, oplist of the type]) */
 #define PRIOQUEUE_OPLIST(...)                                           \
-  PRIOQUEUEI_OPLIST(M_IF_NARGS_EQ1(__VA_ARGS__)                         \
-                    ((__VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__) ), \
-                     (__VA_ARGS__ )))
+  PRIOQUEUEI_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                      \
+                       ((__VA_ARGS__, M_DEFAULT_OPLIST),                \
+                        (__VA_ARGS__ )))
+
 
 
 /********************************** INTERNAL ************************************/
 
-#define PRIOQUEUEI_OPLIST(arg) PRIOQUEUEI_OPLIST2 arg
-#define PRIOQUEUEI_DEF(arg)    PRIOQUEUEI_DEF2 arg
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define PRIOQUEUEI_OPLIST_P1(arg) PRIOQUEUEI_OPLIST_P2 arg
 
-#define PRIOQUEUEI_OPLIST2(name, oplist)                                \
+/* Validation of the given oplist */
+#define PRIOQUEUEI_OPLIST_P2(name, oplist)					\
+  M_IF_OPLIST(oplist)(PRIOQUEUEI_OPLIST_P3, PRIOQUEUEI_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define PRIOQUEUEI_OPLIST_FAILURE(name, oplist)		\
+  M_LIB_ERROR(ARGUMENT_OF_PRIOQUEUE_OPLIST_IS_NOT_AN_OPLIST, name, oplist)
+
+/* Define oplist of a priority queue */
+#define PRIOQUEUEI_OPLIST_P3(name, oplist)                              \
   (INIT(M_C(name, _init))						\
    ,INIT_SET(M_C(name, _init_set))					\
+   ,INIT_WITH(API_1(M_INIT_VAI))                                        \
    ,SET(M_C(name, _set))						\
    ,CLEAR(M_C(name, _clear))						\
    ,INIT_MOVE(M_C(name, _init_move))					\
@@ -64,9 +77,31 @@
    ,PUSH(M_C(name,_push))						\
    ,POP(M_C(name,_pop))                                                 \
    ,OPLIST(oplist)                                                      \
+   ,TEST_EMPTY(M_C(name, _empty_p)),                                    \
+   ,GET_SIZE(M_C(name, _size))                                          \
    )
 
-#define PRIOQUEUEI_DEF2(name, type, oplist, prioqueue_t, it_t)          \
+
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define PRIOQUEUEI_DEF_P1(arg)    PRIOQUEUEI_DEF_P2 arg
+
+/* Validate the oplist before going further */
+#define PRIOQUEUEI_DEF_P2(name, type, oplist, prioqueue_t, it_t)                         \
+  M_IF_OPLIST(oplist)(PRIOQUEUEI_DEF_P3, PRIOQUEUEI_DEF_FAILURE)(name, type, oplist, prioqueue_t, it_t)
+
+/* Stop processing with a compilation failure */
+#define PRIOQUEUEI_DEF_FAILURE(name, type, oplist, prioqueue_t, it_t)                      \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(PRIOQUEUE_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* Define the priority queue:
+   - name: prefix to use,
+   - type: type of the contained objects,
+   - oplist: oplist of the contained objects,
+   - prioqueue_t: type of the container,
+   - it_t: iterator of the container
+*/
+#define PRIOQUEUEI_DEF_P3(name, type, oplist, prioqueue_t, it_t)        \
   ARRAY_DEF(M_C(name, _array), type, oplist)                            \
                                                                         \
   typedef type M_C(name, _type_t);					\
@@ -74,9 +109,13 @@
   typedef struct M_C(name, _s) {                                        \
     M_C(name, _array_t) array;                                          \
   } prioqueue_t[1];                                                     \
+  typedef struct M_C(name, _s) *M_C(name, _ptr);                        \
+  typedef const struct M_C(name, _s) *M_C(name, _srcptr);               \
                                                                         \
   typedef M_C(name, _array_it_t) it_t;                                  \
                                                                         \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                      \
+                                                                        \
   static inline void                                                    \
   M_C(name, _init)(prioqueue_t p)                                       \
   {                                                                     \
@@ -84,13 +123,13 @@
   }                                                                     \
                                                                         \
   static inline void                                                    \
-  M_C(name, _init_set)(prioqueue_t p, prioqueue_t o)                    \
+  M_C(name, _init_set)(prioqueue_t p, prioqueue_t const o)              \
   {                                                                     \
     M_C(name, _array_init_set)(p->array, o->array);                     \
   }                                                                     \
                                                                         \
   static inline void                                                    \
-  M_C(name, _set)(prioqueue_t p, prioqueue_t o)                         \
+  M_C(name, _set)(prioqueue_t p, prioqueue_t const o)                   \
   {                                                                     \
     M_C(name, _array_set)(p->array, o->array);                          \
   }                                                                     \
@@ -147,20 +186,20 @@
   }                                                                     \
                                                                         \
   static inline int                                                     \
-  M_C(name, _i_cmp)(prioqueue_t p, size_t i, size_t j)                  \
+  M_C(name, _i_cmp)(const prioqueue_t p, size_t i, size_t j)            \
   {                                                                     \
-    return M_GET_CMP oplist (*M_C(name, _array_get)(p->array, i),       \
-                             *M_C(name, _array_get)(p->array, j));      \
+    return M_CALL_CMP(oplist, *M_C(name, _array_cget)(p->array, i),     \
+                      *M_C(name, _array_cget)(p->array, j));            \
   }                                                                     \
                                                                         \
   static inline bool                                                    \
-  M_C(name, _empty_p)(prioqueue_t p)                                    \
+  M_C(name, _empty_p)(prioqueue_t const p)                              \
   {                                                                     \
     return M_C(name, _array_empty_p)(p->array);                         \
   }                                                                     \
                                                                         \
   static inline size_t                                                  \
-  M_C(name, _size)(prioqueue_t p)                                       \
+  M_C(name, _size)(prioqueue_t const p)                                 \
   {                                                                     \
     return M_C(name, _array_size)(p->array);                            \
   }                                                                     \
@@ -180,10 +219,10 @@
     }                                                                   \
   }                                                                     \
                                                                         \
-  static inline type *                                                  \
-  M_C(name, _front)(prioqueue_t p)                                      \
+  static inline type const *                                            \
+  M_C(name, _front)(prioqueue_t const p)                                \
   {                                                                     \
-    return M_C(name, _array_get)(p->array, 0);                          \
+    return M_C(name, _array_cget)(p->array, 0);                         \
   }                                                                     \
                                                                         \
   static inline void                                                    \
@@ -209,19 +248,19 @@
   }                                                                     \
                                                                         \
   static inline void                                                    \
-  M_C(name, _it)(it_t it, const prioqueue_t v)                          \
+  M_C(name, _it)(it_t it, prioqueue_t const v)                          \
   {                                                                     \
     M_C(name, _array_it)(it, v->array);                                 \
   }                                                                     \
                                                                         \
   static inline void                                                    \
-  M_C(name, _it_last)(it_t it, const prioqueue_t v)			\
+  M_C(name, _it_last)(it_t it, prioqueue_t const v)			\
   {                                                                     \
     M_C(name, _array_it_last)(it, v->array);                            \
   }                                                                     \
                                                                         \
   static inline void                                                    \
-  M_C(name, _it_end)(it_t it, const prioqueue_t v)			\
+  M_C(name, _it_end)(it_t it, prioqueue_t const v)			\
   {                                                                     \
     M_C(name, _array_it_end)(it, v->array);                             \
   }                                                                     \
@@ -263,11 +302,83 @@
     M_C(name, _array_previous)(it);                                     \
   }                                                                     \
                                                                         \
-  static inline const type *                                            \
+  static inline type const *                                            \
   M_C(name, _cref)(const it_t it)					\
   {                                                                     \
     return M_C(name, _array_cref)(it);                                  \
   }                                                                     \
+                                                                        \
+  M_IF_METHOD(EQUAL, oplist)                                            \
+  (                                                                     \
+   /* EQUAL & CMP may be uncorrelated */                                \
+   static inline bool                                                   \
+   M_C(name, _erase)(prioqueue_t p, type x)                             \
+   {                                                                    \
+     /* First pass: search for an item EQUAL to x */                    \
+     /* NOTE: An HASHMAP may be a good idea to optimize this pass. */   \
+     size_t size = M_C(name, _array_size)(p->array);                    \
+     size_t i = 0;                                                      \
+     for(i = 0; i < size; i++) {                                        \
+       if (M_CALL_EQUAL(oplist, *M_C(name, _array_cget)(p->array, i), x)) \
+         break;                                                         \
+     }                                                                  \
+     /* If x is not found, then stop */                                 \
+     if (i >= size)                                                     \
+       return false;                                                    \
+     /* Swap the found item and the last element */                     \
+     size--;                                                            \
+     M_C(name, _array_swap_at) (p->array, i, size);                     \
+     M_C(name, _array_pop_back)(NULL, p->array);                        \
+     /* Move back the last swapped element to its right position in the heap */ \
+     while (true) {                                                     \
+       size_t child = M_C(name, _i_lchild)(i);                          \
+       if (child >= size) break;                                        \
+       size_t otherChild = M_C(name, _i_rchild)(i);                     \
+       if (otherChild < size                                            \
+           && M_C(name, _i_cmp)(p, otherChild, child) < 0 ) {           \
+         child = otherChild;                                            \
+       }                                                                \
+       if (M_C(name, _i_cmp)(p, i, child) <= 0) break;                  \
+       M_C(name, _array_swap_at) (p->array, i, child);                  \
+       i = child;                                                       \
+     }                                                                  \
+     return true;                                                       \
+   }                                                                    \
+                                                                        \
+   static inline void                                                   \
+   M_C(name, _update_further)(prioqueue_t p, type xold, type xnew)      \
+   {                                                                    \
+     /* This update assumes that the new position is further in the heap */ \
+     assert (M_CALL_CMP(oplist, xold, xnew) > 0);                       \
+     /* First pass: search for an item EQUAL to x */                    \
+     size_t size = M_C(name, _array_size)(p->array);                    \
+     size_t i = 0;                                                      \
+     for(i = 0; i < size; i++) {                                        \
+       if (M_CALL_EQUAL(oplist, *M_C(name, _array_cget)(p->array, i), xold)) \
+         break;                                                         \
+     }                                                                  \
+     /* We shall have found the item */                                 \
+     assert (i < size);                                                 \
+     /* Set the found item to the new element */                        \
+     M_C(name, _array_set_at) (p->array, i, xnew);                      \
+     /* Move back the updated element to its right position in the heap */ \
+     while (true) {                                                     \
+       size_t child = M_C(name, _i_lchild)(i);                          \
+       if (child >= size) break;                                        \
+       size_t otherChild = M_C(name, _i_rchild)(i);                     \
+       if (otherChild < size                                            \
+           && M_C(name, _i_cmp)(p, otherChild, child) < 0 ) {           \
+         child = otherChild;                                            \
+       }                                                                \
+       if (M_C(name, _i_cmp)(p, i, child) <= 0) break;                  \
+       M_C(name, _array_swap_at) (p->array, i, child);                  \
+       i = child;                                                       \
+     }                                                                  \
+   }                                                                    \
+                                                                        \
+   , /* No EQUAL */ )							\
+   
+
+// TODO: set all & remove all function
 
-  
 #endif

m-serial-bin.h

@@ -0,0 +1,496 @@
+/*
+ * M*LIB - Serial BIN
+ *
+ * Copyright (c) 2017-2020, 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.
+*/
+#ifndef MSTARLIB_SERIAL_BIN_H
+#define MSTARLIB_SERIAL_BIN_H
+
+#include <stdint.h>
+
+#include "m-core.h"
+#include "m-string.h"
+
+/* Write the boolean 'data' into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline m_serial_return_code_t
+m_serial_bin_write_boolean(m_serial_write_t serial, const bool data)
+{
+  FILE *f = (FILE *)serial->data[0].p;
+  size_t n = fwrite (M_ASSIGN_CAST(const void*, &data), sizeof (bool), 1, f);
+  return n == 1 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Write the integer 'data' of 'size_of_type' bytes into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline m_serial_return_code_t
+m_serial_bin_write_integer(m_serial_write_t serial,const long long data, const size_t size_of_type)
+{
+  int8_t   i8;
+  int16_t i16;
+  int32_t i32;
+  int64_t i64;
+  size_t n;
+  
+  FILE *f = (FILE *)serial->data[0].p;
+  switch (size_of_type) {
+  case 1:
+    i8 = data;
+    n = fwrite (M_ASSIGN_CAST(const void*, &i8), sizeof i8, 1, f);
+    break;
+  case 2:
+    i16 = data;
+    n = fwrite (M_ASSIGN_CAST(const void*, &i16), sizeof i16, 1, f);
+    break;
+  case 4:
+    i32 = data;
+    n = fwrite (M_ASSIGN_CAST(const void*, &i32), sizeof i32, 1, f);
+    break;
+  case 8:
+    i64 = data;
+    n = fwrite (M_ASSIGN_CAST(const void*, &i64), sizeof i64, 1, f);
+    break;
+  default:
+    M_ASSERT_INIT(false, "an integer of suitable size");
+    break;
+  }
+  return n == 1 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Write the float 'data' of 'size_of_type' bytes into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline m_serial_return_code_t
+m_serial_bin_write_float(m_serial_write_t serial, const long double data, const size_t size_of_type)
+{
+  float   f1;
+  double  f2;
+  long double f3;
+  size_t n;
+  
+  FILE *f = (FILE *)serial->data[0].p;
+  if (size_of_type == sizeof f1) {
+    f1 = data;
+    n = fwrite (M_ASSIGN_CAST(const void*, &f1), sizeof f1, 1, f);
+  } else if (size_of_type == sizeof f2) {
+    f2 = data;
+    n = fwrite (M_ASSIGN_CAST(const void*, &f2), sizeof f2, 1, f);
+  } else if (size_of_type == sizeof f3) {
+    f3 = data;
+    n = fwrite (M_ASSIGN_CAST(const void*, &f3), sizeof f3, 1, f);
+  } else {
+    M_ASSERT_INIT(false, "a float of suitable size");
+  }
+  return n == 1 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Write the null-terminated string 'data'into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline m_serial_return_code_t
+m_serial_bin_write_string(m_serial_write_t serial, const char data[])
+{
+  FILE *f = (FILE *)serial->data[0].p;
+  size_t l = strlen(data);
+  size_t n = fwrite (M_ASSIGN_CAST(const void*, data), 1, l+1, f);
+  return n == l+1 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Start writing an array of 'number_of_elements' objects into the serial stream 'serial'.
+   If 'number_of_elements' is 0, then either the array has no data,
+   or the number of elements of the array is unkown.
+   Initialize 'local' so that it can be used to serialize the array 
+   (local is an unique serialization object of the array).
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline m_serial_return_code_t
+m_serial_bin_write_array_start(m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
+{
+  FILE *f = (FILE *)serial->data[0].p;
+  size_t n = fwrite (M_ASSIGN_CAST(const void*, &number_of_elements), sizeof number_of_elements, 1, f);
+  local->data[0].b = (number_of_elements == 0);
+  return n == 1 ? M_SERIAL_OK_CONTINUE : M_SERIAL_FAIL;
+}
+
+/* Write an array separator between elements of an array into the serial stream 'serial' if needed.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_bin_write_array_next(m_serial_local_t local, m_serial_write_t serial)
+{
+  FILE *f = (FILE *)serial->data[0].p;
+  // Need separator if we don't know the real size 
+  if (local->data[0].b) {
+    size_t n = 0xABCDEF;
+    n = fwrite (M_ASSIGN_CAST(const void*, &n), sizeof n, 1, f);
+    return n == 1 ? M_SERIAL_OK_CONTINUE : M_SERIAL_FAIL;    
+  } else {
+    return M_SERIAL_OK_CONTINUE;
+  }
+}
+
+/* End the writing of an array into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_bin_write_array_end(m_serial_local_t local, m_serial_write_t serial)
+{
+  FILE *f = (FILE *)serial->data[0].p;
+  // Need mark if we don't know the real size 
+  if (local->data[0].b) {
+    size_t n = 0x12345678;
+    n = fwrite (M_ASSIGN_CAST(const void*, &n), sizeof n, 1, f);
+    return n == 1 ? M_SERIAL_OK_CONTINUE : M_SERIAL_FAIL;    
+  } else {
+    return M_SERIAL_OK_CONTINUE;
+  }
+}
+
+/* Write a value separator between element of the same pair of a map into the serial stream 'serial' if needed.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_bin_write_map_value(m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  (void) serial;
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Start writing a tuple into the serial stream 'serial'.
+   Initialize 'local' so that it can serial the tuple 
+   (local is an unique serialization object of the tuple).
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_bin_write_tuple_start(m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  (void) serial;
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Start writing the field named field_name[index] of a tuple into the serial stream 'serial'.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_bin_write_tuple_id(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
+{
+  (void) local; // argument not used
+  (void) serial;
+  (void) field_name;
+  (void) max;
+  (void) index; // Assume index are write in order from 0 to max.
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* End the write of a tuple into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_bin_write_tuple_end(m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  (void) serial;
+  return M_SERIAL_OK_DONE;
+}
+
+/* Start writing a variant into the serial stream 'serial'.
+   If index <= 0, the variant is empty.
+     Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise 
+   Otherwise, the field 'field_name[index]' will be filled.
+     Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_bin_write_variant_start(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
+{
+  (void) field_name;
+  (void) max;
+  (void) local;
+  FILE *f = (FILE *)serial->data[0].p;
+  size_t n = fwrite (M_ASSIGN_CAST(const void*, &index), sizeof index, 1, f);
+  return n == 1 ? ((index < 0) ? M_SERIAL_OK_DONE : M_SERIAL_OK_CONTINUE) : M_SERIAL_FAIL;
+}
+
+/* End Writing a variant into the serial stream 'serial'. 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_bin_write_variant_end(m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  (void) serial;
+  return M_SERIAL_OK_DONE;
+}
+
+/* The exported interface. */
+static const m_serial_write_interface_t m_serial_write_bin_interface = {
+  m_serial_bin_write_boolean,
+  m_serial_bin_write_integer,
+  m_serial_bin_write_float,
+  m_serial_bin_write_string, 
+  m_serial_bin_write_array_start,
+  m_serial_bin_write_array_next,
+  m_serial_bin_write_array_end,
+  m_serial_bin_write_array_start,
+  m_serial_bin_write_map_value,
+  m_serial_bin_write_array_next,
+  m_serial_bin_write_array_end,
+  m_serial_bin_write_tuple_start,
+  m_serial_bin_write_tuple_id,
+  m_serial_bin_write_tuple_end,
+  m_serial_bin_write_variant_start,
+  m_serial_bin_write_variant_end
+};
+
+static inline void m_serial_bin_write_init(m_serial_write_t serial, FILE *f)
+{
+  serial->m_interface = &m_serial_write_bin_interface;
+  serial->data[0].p = M_ASSIGN_CAST(void*, f);
+}
+
+static inline void m_serial_bin_write_clear(m_serial_write_t serial)
+{
+  (void) serial; // Nothing to do
+}
+
+
+/* Read from the stream 'serial' a boolean.
+   Set '*b' with the boolean value if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_bin_read_boolean(m_serial_read_t serial, bool *b){
+  FILE *f = (FILE*) serial->data[0].p;
+  size_t n = fread (M_ASSIGN_CAST(void*, b), sizeof (bool), 1, f);
+  return n == 1 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Read from the stream 'serial' an integer that can be represented with 'size_of_type' bytes.
+   Set '*i' with the integer value if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_bin_read_integer(m_serial_read_t serial, long long *i, const size_t size_of_type){
+  int8_t   i8;
+  int16_t i16;
+  int32_t i32;
+  int64_t i64;
+  size_t n;
+  FILE *f = (FILE *)serial->data[0].p;
+  switch (size_of_type) {
+  case 1:
+    n = fread (M_ASSIGN_CAST(void*, &i8), sizeof i8, 1, f);
+    *i = i8;
+    break;
+  case 2:
+    n = fread (M_ASSIGN_CAST(void*, &i16), sizeof i16, 1, f);
+    *i = i16;
+    break;
+  case 4:
+    n = fread (M_ASSIGN_CAST(void*, &i32), sizeof i32, 1, f);
+    *i = i32;
+    break;
+  case 8:
+    n = fread (M_ASSIGN_CAST(void*, &i64), sizeof i64, 1, f);
+    *i = i64;
+    break;
+  default:
+    M_ASSERT_INIT(false, "an integer of suitable size");
+    break;
+  }
+  return n == 1 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Read from the stream 'serial' a float that can be represented with 'size_of_type' bytes.
+   Set '*r' with the boolean value if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_bin_read_float(m_serial_read_t serial, long double *r, const size_t size_of_type){
+  float   f1;
+  double  f2;
+  long double f3;
+  size_t n;
+  FILE *f = (FILE *)serial->data[0].p;
+  if (size_of_type == sizeof f1) {
+    n = fread (M_ASSIGN_CAST(void*, &f1), sizeof f1, 1, f);
+    *r = f1;
+  } else if (size_of_type == sizeof f2) {
+    n = fread (M_ASSIGN_CAST(void*, &f2), sizeof f2, 1, f);
+    *r = f2;
+  } else if (size_of_type == sizeof f3) {
+    n = fread (M_ASSIGN_CAST(void*, &f3), sizeof f3, 1, f);
+    *r = f3;
+  } else {
+    M_ASSERT_INIT(false, "a float of suitable size");
+  }
+  return n == 1 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Read from the stream 'serial' a string.
+   Set 's' with the string if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_bin_read_string(m_serial_read_t serial, struct string_s *s){
+  FILE *f = (FILE*) serial->data[0].p;
+  string_clean(s);
+  int c;
+  c = fgetc(f);
+  while (c != 0 && c != EOF) {
+    string_push_back(s, c);
+    c = fgetc(f);
+  }
+  return c != EOF ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Start reading from the stream 'serial' an array.
+   Set '*num' with the number of elements, or 0 if it is not known.
+   Initialize 'local' so that it can be used to serialize the array 
+   (local is an unique serialization object of the array).
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the array continue,
+   M_SERIAL_OK_DONE if it succeeds and the array ends (the array is empty),
+   M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_bin_read_array_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
+{
+  FILE *f = (FILE*) serial->data[0].p;
+  size_t n = fread (M_ASSIGN_CAST(void*, num), sizeof *num, 1, f);
+  if (n != 1)
+    return M_SERIAL_FAIL;
+  local->data[0].b = (*num == 0);
+  local->data[1].s = *num;
+  if (local->data[0].b) {
+    // Size not know ==> use of marker in the stream.
+    size_t p;
+    n = fread (M_ASSIGN_CAST(void*, &p), sizeof p, 1, f);
+    if (n != 1)
+      return M_SERIAL_FAIL;
+    return p == 0xABCDEF ? M_SERIAL_OK_CONTINUE : p == 0x12345678 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+  }
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Continue reading from the stream 'serial' an array.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the array continue,
+   M_SERIAL_OK_DONE if it succeeds and the array ends,
+   M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_bin_read_array_next(m_serial_local_t local, m_serial_read_t serial)
+{
+  FILE *f = (FILE*) serial->data[0].p;
+  if (local->data[0].b) {
+    // Size not know ==> use of marker in the stream.
+    size_t p, n;
+    n = fread (M_ASSIGN_CAST(void*, &p), sizeof p, 1, f);
+    if (n != 1)
+      return M_SERIAL_FAIL;
+    return p == 0xABCDEF ? M_SERIAL_OK_CONTINUE : p == 0x12345678 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+  } else {
+    assert(local->data[1].s > 0);
+    local->data[1].s --;
+    return local->data[1].s == 0 ? M_SERIAL_OK_DONE : M_SERIAL_OK_CONTINUE;
+  }
+}
+
+
+/* Continue reading from the stream 'serial' the value separator
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the map continue,
+   M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_bin_read_map_value(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  (void) serial;
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Start reading a tuple from the stream 'serial'.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the tuple continues,
+   M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_bin_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) serial;
+  local->data[1].s = 0;
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Continue reading a tuple from the stream 'serial'.
+   Set '*id' with the corresponding index of the table 'field_name[max]'
+   associated to the parsed field in the stream.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the tuple continues,
+   Return M_SERIAL_OK_DONE if it succeeds and the tuple ends,
+   M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_bin_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, const char *const field_name [], const int max, int *id)
+{
+  (void) serial;
+  (void) field_name;
+  (void) max;
+  *id = local->data[1].s;
+  local->data[1].s ++;
+  return (*id == max) ? M_SERIAL_OK_DONE : M_SERIAL_OK_CONTINUE;
+}
+
+/* Start reading a variant from the stream 'serial'.
+   Set '*id' with the corresponding index of the table 'field_name[max]'
+   associated to the parsed field in the stream.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the variant continues,
+   Return M_SERIAL_OK_DONE if it succeeds and the variant ends(variant is empty),
+   M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_bin_read_variant_start(m_serial_local_t local, m_serial_read_t serial, const char *const field_name[], const int max, int*id)
+{
+  (void) field_name;
+  (void) max;
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  size_t n = fread (M_ASSIGN_CAST(void*, id), sizeof *id, 1, f);
+  return n == 1 ? ((*id < 0) ? M_SERIAL_OK_DONE : M_SERIAL_OK_CONTINUE) : M_SERIAL_FAIL;
+}
+
+/* End reading a variant from the stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds and the variant ends,
+   M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_bin_read_variant_end(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  (void) serial;
+  return M_SERIAL_OK_DONE;
+}
+
+static const m_serial_read_interface_t m_serial_bin_read_interface = {
+  m_serial_bin_read_boolean,
+  m_serial_bin_read_integer,
+  m_serial_bin_read_float,
+  m_serial_bin_read_string,
+  m_serial_bin_read_array_start,
+  m_serial_bin_read_array_next,
+  m_serial_bin_read_array_start,
+  m_serial_bin_read_map_value,
+  m_serial_bin_read_array_next,
+  m_serial_bin_read_tuple_start,
+  m_serial_bin_read_tuple_id,
+  m_serial_bin_read_variant_start,
+  m_serial_bin_read_variant_end
+};
+
+static inline void m_serial_bin_read_init(m_serial_read_t serial, FILE *f)
+{
+  serial->m_interface = &m_serial_bin_read_interface;
+  serial->data[0].p = M_ASSIGN_CAST(void*, f);
+}
+
+static inline void m_serial_bin_read_clear(m_serial_read_t serial)
+{
+  (void) serial; // Nothing to do
+}
+
+#endif

m-serial-json.h

@@ -0,0 +1,558 @@
+/*
+ * M*LIB - Serial JSON
+ *
+ * Copyright (c) 2017-2020, 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.
+*/
+#ifndef MSTARLIB_SERIAL_JSON_H
+#define MSTARLIB_SERIAL_JSON_H
+
+#include "m-core.h"
+#include "m-string.h"
+
+/* Write the boolean 'data' into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline m_serial_return_code_t
+m_serial_json_write_boolean(m_serial_write_t serial, const bool data)
+{
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "%s", data ? "true" : "false");
+  return n > 0 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Write the integer 'data' of 'size_of_type' bytes into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline m_serial_return_code_t
+m_serial_json_write_integer(m_serial_write_t serial,const long long data, const size_t size_of_type)
+{
+  (void) size_of_type; // Ignored
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "%lld", data);
+  return n > 0 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;  
+}
+
+/* Write the float 'data' of 'size_of_type' bytes into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline m_serial_return_code_t
+m_serial_json_write_float(m_serial_write_t serial, const long double data, const size_t size_of_type)
+{
+  (void) size_of_type; // Ignored
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "%Lf", data);
+  return n > 0 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Write the null-terminated string 'data'into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline m_serial_return_code_t
+m_serial_json_write_string(m_serial_write_t serial, const char data[])
+{
+  FILE *f = (FILE *)serial->data[0].p;
+  /* Build dummy string to reuse string_out_str */
+  string_t v2;
+  uintptr_t ptr = (uintptr_t) data;
+  v2->u.heap.size = strlen(data);
+  v2->u.heap.alloc = v2->u.heap.size + 1;
+  v2->ptr = (char*)ptr;
+  string_out_str(f, v2);
+  return M_SERIAL_OK_DONE;
+}
+
+/* Start writing an array of 'number_of_elements' objects into the serial stream 'serial'.
+   If 'number_of_elements' is 0, then either the array has no data,
+   or the number of elements of the array is unkown.
+   Initialize 'local' so that it can be used to serialize the array 
+   (local is an unique serialization object of the array).
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline m_serial_return_code_t
+m_serial_json_write_array_start(m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
+{
+  (void) local; // argument not used
+  (void) number_of_elements; // Ignored
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "[");
+  return n > 0 ? M_SERIAL_OK_CONTINUE : M_SERIAL_FAIL;
+}
+
+/* Write an array separator between elements of an array into the serial stream 'serial' if needed.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_json_write_array_next(m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, ",");
+  return n > 0 ? M_SERIAL_OK_CONTINUE : M_SERIAL_FAIL;
+}
+
+/* End the writing of an array into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_json_write_array_end(m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "]");
+  return n > 0 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Start writing a map of 'number_of_elements' pairs of objects into the serial stream 'serial'.
+   If 'number_of_elements' is 0, then either the map has no data,
+   or the number of elements is unkown.
+   Initialize 'local' so that it can be used to serialize the map 
+   (local is an unique serialization object of the map).
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_json_write_map_start(m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
+{
+  (void) local; // argument not used
+  (void) number_of_elements; // Ignored
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "{");
+  return n > 0 ? M_SERIAL_OK_CONTINUE : M_SERIAL_FAIL;
+}
+
+/* Write a value separator between element of the same pair of a map into the serial stream 'serial' if needed.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_json_write_map_value(m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, ":");
+  return n > 0 ? M_SERIAL_OK_CONTINUE : M_SERIAL_FAIL;
+}
+
+/* Write a map separator between elements of a map into the serial stream 'serial' if needed.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_json_write_map_next(m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, ",");
+  return n > 0 ? M_SERIAL_OK_CONTINUE : M_SERIAL_FAIL;
+}
+
+/* End the writing of a map into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_json_write_map_end(m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "}");
+  return n > 0 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Start writing a tuple into the serial stream 'serial'.
+   Initialize 'local' so that it can serial the tuple 
+   (local is an unique serialization object of the tuple).
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_json_write_tuple_start(m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "{");
+  return n > 0 ? M_SERIAL_OK_CONTINUE : M_SERIAL_FAIL;
+}
+
+/* Start writing the field named field_name[index] of a tuple into the serial stream 'serial'.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_json_write_tuple_id(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
+{
+  (void) local; // argument not used
+  (void) max; // Ignored
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "%c\"%s\":", index == 0 ? ' ' : ',', field_name[index]);
+  return n > 0 ? M_SERIAL_OK_CONTINUE : M_SERIAL_FAIL;
+}
+
+/* End the write of a tuple into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_json_write_tuple_end(m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "}");
+  return n > 0 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Start writing a variant into the serial stream 'serial'.
+   If index <= 0, the variant is empty.
+     Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise 
+   Otherwise, the field 'field_name[index]' will be filled.
+     Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_json_write_variant_start(m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
+{
+  (void) local; // argument not used
+  (void) max; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n;
+  if (index >= 0) {
+    assert (index < max);
+    n = fprintf(f, "{\"%s\":", field_name[index]);
+    return n > 0 ? M_SERIAL_OK_CONTINUE : M_SERIAL_FAIL;
+  } else {
+    n = fprintf(f, "{}");
+    return n > 0 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+  }
+}
+
+/* End Writing a variant into the serial stream 'serial'. 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline   m_serial_return_code_t
+m_serial_json_write_variant_end(m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "}");
+  return n > 0 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* The internal exported interface of m_serial_write_json. */
+static const m_serial_write_interface_t m_serial_write_json_interface = {
+  m_serial_json_write_boolean,
+  m_serial_json_write_integer,
+  m_serial_json_write_float,
+  m_serial_json_write_string, 
+  m_serial_json_write_array_start,
+  m_serial_json_write_array_next,
+  m_serial_json_write_array_end,
+  m_serial_json_write_map_start,
+  m_serial_json_write_map_value,
+  m_serial_json_write_map_next,
+  m_serial_json_write_map_end,
+  m_serial_json_write_tuple_start,
+  m_serial_json_write_tuple_id,
+  m_serial_json_write_tuple_end,
+  m_serial_json_write_variant_start,
+  m_serial_json_write_variant_end
+};
+
+/* Initialize the JSON serial object for writing any object to JSON format in the given FILE */
+static inline void m_serial_json_write_init(m_serial_write_t serial, FILE *f)
+{
+  serial->m_interface = &m_serial_write_json_interface;
+  serial->data[0].p = M_ASSIGN_CAST(void*, f);
+}
+
+/* CLear the JSON serial object for writing*/
+static inline void m_serial_json_write_clear(m_serial_write_t serial)
+{
+  (void) serial; // Nothing to do
+}
+
+/* Define a synonym to the JSON serializer with a proper OPLIST */
+typedef m_serial_write_t m_serial_json_write_t;
+#define M_OPL_m_serial_json_write_t()                                   \
+  (INIT_WITH(m_serial_json_write_init), CLEAR(m_serial_json_write_clear), TYPE(m_serial_json_write_t) )
+
+
+
+/* Helper function to skip a space */
+static inline int
+m_serial_json_read_skip (FILE *f)
+{
+  int c;
+  do {
+    c = fgetc(f);
+  } while (isspace(c));
+  return c;
+}
+
+/* Read from the stream 'serial' a boolean.
+   Set '*b' with the boolean value if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_json_read_boolean(m_serial_read_t serial, bool *b){
+  FILE *f = (FILE*) serial->data[0].p;
+  int c = m_serial_json_read_skip(f);
+  if (c == 't') {
+    *b = true;
+    c = fgetc(f);
+    if (c != 'r') return M_SERIAL_FAIL;
+    c = fgetc(f);
+    if (c != 'u') return M_SERIAL_FAIL;
+    c = fgetc(f);
+    if (c != 'e') return M_SERIAL_FAIL;
+    return M_SERIAL_OK_DONE;
+  } else if (c == 'f') {
+    *b = false;
+    c = fgetc(f);
+    if (c != 'a') return M_SERIAL_FAIL;
+    c = fgetc(f);
+    if (c != 'l') return M_SERIAL_FAIL;
+    c = fgetc(f);
+    if (c != 's') return M_SERIAL_FAIL;
+    c = fgetc(f);
+    if (c != 'e') return M_SERIAL_FAIL;
+    return M_SERIAL_OK_DONE;
+  } else {
+    return M_SERIAL_FAIL;
+  }
+}
+
+/* Read from the stream 'serial' an integer that can be represented with 'size_of_type' bytes.
+   Set '*i' with the integer value if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_json_read_integer(m_serial_read_t serial, long long *i, const size_t size_of_type){
+  (void) size_of_type; // Ignored
+  FILE *f = (FILE*) serial->data[0].p;
+  return fscanf(f, " %lld", i) == 1 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Read from the stream 'serial' a float that can be represented with 'size_of_type' bytes.
+   Set '*r' with the boolean value if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_json_read_float(m_serial_read_t serial, long double *r, const size_t size_of_type){
+  (void) size_of_type; // Ignored
+  FILE *f = (FILE*) serial->data[0].p;
+  return fscanf(f, " %Lf", r) == 1 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Read from the stream 'serial' a string.
+   Set 's' with the string if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_json_read_string(m_serial_read_t serial, struct string_s *s){
+  FILE *f = (FILE*) serial->data[0].p;
+  fscanf(f, " "); // Skip any leading spaces.
+  return string_in_str(s, f) ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Start reading from the stream 'serial' an array.
+   Set '*num' with the number of elements, or 0 if it is not known.
+   Initialize 'local' so that it can be used to serialize the array 
+   (local is an unique serialization object of the array).
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the array continue,
+   M_SERIAL_OK_DONE if it succeeds and the array ends (the array is empty),
+   M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_json_read_array_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  int final1 = -1, final2 = -1;
+  fscanf(f, " [%n ]%n", &final1, &final2);
+  *num = 0; // don't know the size of the array.
+  // Test how much the parsing succeed.
+  return (final1 < 0) ? M_SERIAL_FAIL : (final2 < 0) ? M_SERIAL_OK_CONTINUE : M_SERIAL_OK_DONE;
+}
+
+/* Continue reading from the stream 'serial' an array.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the array continue,
+   M_SERIAL_OK_DONE if it succeeds and the array ends,
+   M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_json_read_array_next(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  char c = 0;
+  fscanf(f, " %c", &c);
+  return c == ',' ? M_SERIAL_OK_CONTINUE : c == ']' ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Start reading from the stream 'serial' a map.
+   Set '*num' with the number of elements, or 0 if it is not known.
+   Initialize 'local' so that it can be used to serialize the array 
+   (local is an unique serialization object of the array).
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the map continue,
+   M_SERIAL_OK_DONE if it succeeds and the map ends (the map is empty),
+   M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_json_read_map_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  int final1 = -1, final2 = -1;
+  fscanf(f, " {%n }%n", &final1, &final2);
+  *num = 0; // don't know the size of the map.
+  // Test how much the parsing succeed.
+  return (final1 < 0) ? M_SERIAL_FAIL : (final2 < 0) ? M_SERIAL_OK_CONTINUE : M_SERIAL_OK_DONE;
+}
+
+/* Continue reading from the stream 'serial' the value separator
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the map continue,
+   M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_json_read_map_value(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  int final = -1;
+  fscanf(f, " :%n", &final);
+  return final > 0 ? M_SERIAL_OK_CONTINUE : M_SERIAL_FAIL;
+}
+
+/* Continue reading from the stream 'serial' a map.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the map continue,
+   M_SERIAL_OK_DONE if it succeeds and the map ends,
+   M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_json_read_map_next(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  char c = 0;
+  fscanf(f, " %c", &c);
+  return c == ',' ? M_SERIAL_OK_CONTINUE : c == '}' ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+/* Start reading a tuple from the stream 'serial'.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the tuple continues,
+   M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_json_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  int final = -1;
+  fscanf(f, " {%n", &final);
+  return final > 0 ? M_SERIAL_OK_CONTINUE : M_SERIAL_FAIL;
+}
+
+/* Continue reading a tuple from the stream 'serial'.
+   Set '*id' with the corresponding index of the table 'field_name[max]'
+   associated to the parsed field in the stream.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the tuple continues,
+   Return M_SERIAL_OK_DONE if it succeeds and the tuple ends,
+   M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_json_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, const char *const field_name [], const int max, int *id)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  int c = m_serial_json_read_skip(f);
+  if (c == EOF) return M_SERIAL_FAIL;
+  if (c == '}') return M_SERIAL_OK_DONE;
+  if (c == ',') {
+     // If first call of read_tuple_id, it is a failure
+     if (*id == -1) return M_SERIAL_FAIL;
+  } else {
+    // c should be \" but let fscanf parse it.
+    ungetc(c, f);
+  }
+  /* Read the field in the JSON */
+  c = -1;
+  char field[M_MAX_IDENTIFIER_LENGTH+1]; // TODO: fix error detection below.
+  fscanf(f, " \"%" M_APPLY(M_AS_STR, M_MAX_IDENTIFIER_LENGTH) "[^ \t\n\"]\":%n", field, &c);
+  if (c <= 0)
+    return M_SERIAL_FAIL;
+  /* Search for field in field_name */
+  for(int n = 0; n < max; n++) {
+    if (strcmp(field, field_name[n]) == 0) {
+      *id = n;
+      return M_SERIAL_OK_CONTINUE;
+    }
+  }
+  return M_SERIAL_FAIL;
+}
+
+/* Start reading a variant from the stream 'serial'.
+   Set '*id' with the corresponding index of the table 'field_name[max]'
+   associated to the parsed field in the stream.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the variant continues,
+   Return M_SERIAL_OK_DONE if it succeeds and the variant ends(variant is empty),
+   M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_json_read_variant_start(m_serial_local_t local, m_serial_read_t serial, const char *const field_name[], const int max, int*id)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+
+  int final1 = -1, final2 = -1;
+  fscanf(f, " {%n }%n", &final1, &final2);
+  // Test how much the parsing succeed.
+  if (final1 <= 0) return M_SERIAL_FAIL;
+  if (final2 > 0)  return M_SERIAL_OK_DONE;
+
+  /* Read the field in the JSON */
+  char field[M_MAX_IDENTIFIER_LENGTH+1];
+  fscanf(f, " \"%" M_APPLY(M_AS_STR, M_MAX_IDENTIFIER_LENGTH) "[^ \t\n\"]\":%n", field, &final2);
+  if (final2 <= 0) return M_SERIAL_FAIL;
+
+  /* Search for field in field_name */
+  for(int n = 0; n < max; n++) {
+    if (strcmp(field, field_name[n]) == 0) {
+      *id = n;
+      return M_SERIAL_OK_CONTINUE;
+    }
+  }
+  return M_SERIAL_FAIL;
+}
+
+/* End reading a variant from the stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds and the variant ends,
+   M_SERIAL_FAIL otherwise */
+static inline  m_serial_return_code_t
+m_serial_json_read_variant_end(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  int final = -1;
+  fscanf(f, " }%n", &final);
+  return final > 0 ? M_SERIAL_OK_DONE : M_SERIAL_FAIL;
+}
+
+static const m_serial_read_interface_t m_serial_json_read_interface = {
+  m_serial_json_read_boolean,
+  m_serial_json_read_integer,
+  m_serial_json_read_float,
+  m_serial_json_read_string,
+  m_serial_json_read_array_start,
+  m_serial_json_read_array_next,
+  m_serial_json_read_map_start,
+  m_serial_json_read_map_value,
+  m_serial_json_read_map_next,
+  m_serial_json_read_tuple_start,
+  m_serial_json_read_tuple_id,
+  m_serial_json_read_variant_start,
+  m_serial_json_read_variant_end
+};
+
+/* Initialize the JSON serial object for reading any object from JSON format in the given FILE */
+static inline void m_serial_json_read_init(m_serial_read_t serial, FILE *f)
+{
+  serial->m_interface = &m_serial_json_read_interface;
+  serial->data[0].p = M_ASSIGN_CAST(void*, f);
+}
+
+/* Clear the JSON serial object for reading from the FILE */
+static inline void m_serial_json_read_clear(m_serial_read_t serial)
+{
+  (void) serial; // Nothing to do
+}
+
+/* Define a synonym of m_serial_read_t 
+  to the JSON serializer with its proper OPLIST */
+typedef m_serial_read_t m_serial_json_read_t;
+#define M_OPL_m_serial_json_read_t()                                    \
+  (INIT_WITH(m_serial_json_read_init), CLEAR(m_serial_json_read_clear), TYPE(m_serial_json_read_t) )
+
+#endif

m-shared.h

@@ -1,7 +1,7 @@
 /*
  * M*LIB - SHARED Module
  *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2020, 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:
@@ -22,8 +22,8 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#ifndef __M_SHARED_PTR__H
-#define __M_SHARED_PTR__H
+#ifndef MSTARLIB_SHARED_PTR_H
+#define MSTARLIB_SHARED_PTR_H
 
 #include "m-core.h"
 #include "m-atomic.h"
@@ -32,40 +32,51 @@
 /* Define the oplist of a shared pointer.
    USAGE: SHARED_OPLIST(name [, oplist_of_the_type]) */
 #define SHARED_PTR_OPLIST(...)                                          \
-  SHAREDI_PTR_OPLIST(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
-                     ((__VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__) ), \
-                      _OPLIST(__VA_ARGS__ )))
+  SHAREDI_PTR_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                     \
+                        ((__VA_ARGS__, M_DEFAULT_OPLIST ),              \
+                         (__VA_ARGS__ )))
+
 
 /* Define shared pointer and its function.
    USAGE: SHARED_PTR_DEF(name, type, [, oplist]) */
 #define SHARED_PTR_DEF(name, ...)                                       \
-  SHAREDI_PTR_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                           \
-                  ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__), SHAREDI_ATOMIC_OPLIST ), \
-                   (name, __VA_ARGS__ , SHAREDI_ATOMIC_OPLIST)))
+  SHAREDI_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
+                     ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), SHAREDI_ATOMIC_OPLIST ), \
+                      (name, __VA_ARGS__ , SHAREDI_ATOMIC_OPLIST)))
+
 
 /* Define relaxed shared pointer and its function (thread unsafe).
    USAGE: SHARED_PTR_RELAXED_DEF(name, type, [, oplist]) */
 #define SHARED_PTR_RELAXED_DEF(name, ...)                               \
-  SHAREDI_PTR_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                           \
-                  ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__), SHAREDI_INTEGER_OPLIST ), \
-                   (name, __VA_ARGS__ , SHAREDI_INTEGER_OPLIST)))
+  SHAREDI_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
+                     ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), SHAREDI_INTEGER_OPLIST ), \
+                      (name, __VA_ARGS__ , SHAREDI_INTEGER_OPLIST)))
+
 
 /* Define shared resource and its function.
    This is a bounded pool of resource shared by multiple owners.
    USAGE: SHARED_RESOURCE_DEF(name, type, [, oplist]) */
 #define SHARED_RESOURCE_DEF(name, ...)                                 \
-  SHAREDI_RESOURCE_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                     \
-                        ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__) ), \
-                         (name, __VA_ARGS__)))
+  SHAREDI_RESOURCE_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                   \
+                          ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__) ), \
+                           (name, __VA_ARGS__)))
 
 
 
 /********************************** INTERNAL ************************************/
 
-// deferred
-#define SHAREDI_PTR_OPLIST(arg) SHAREDI_PTR_OPLIST2 arg
+// deferred evaluation
+#define SHAREDI_PTR_OPLIST_P1(arg) SHAREDI_PTR_OPLIST_P2 arg
 
-#define SHAREDI_PTR_OPLIST2(name, oplist) (                             \
+/* Validation of the given oplist */
+#define SHAREDI_PTR_OPLIST_P2(name, oplist)				\
+  M_IF_OPLIST(oplist)(SHAREDI_PTR_OPLIST_P3, SHAREDI_PTR_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define SHAREDI_PTR_OPLIST_FAILURE(name, oplist)			\
+  M_LIB_ERROR(ARGUMENT_OF_SHARED_PTR_OPLIST_IS_NOT_AN_OPLIST, name, oplist)
+
+#define SHAREDI_PTR_OPLIST_P3(name, oplist) (                           \
   INIT(M_C(name, _init)),                                               \
   CLEAR(M_C(name, _clear)),                                             \
   INIT_SET(M_C(name, _init_set)),                                       \
@@ -74,14 +85,12 @@
   CLEAN(M_C(name, _clean)),                                             \
   MOVE(M_C(name, _move)),                                               \
   SWAP(M_C(name, _swap))                                                \
+  ,TYPE(M_C(name, _t))                                                  \
   ,M_IF_METHOD(NEW, oplist)(NEW(M_GET_NEW oplist),)                     \
   ,M_IF_METHOD(REALLOC, oplist)(REALLOC(M_GET_REALLOC oplist),)         \
   ,M_IF_METHOD(DEL, oplist)(DEL(M_GET_DEL oplist),)                     \
   )
 
-// deferred
-#define SHAREDI_PTR_DEF(arg) SHAREDI_PTR_DEF2 arg
-
 // OPLIST to handle a counter of atomic type
 #define SHAREDI_ATOMIC_OPLIST (TYPE(atomic_int),                        \
                                INIT_SET(atomic_init),                   \
@@ -89,35 +98,54 @@
                                SUB(atomic_fetch_sub),                   \
                                IT_CREF(atomic_load))
 
-// OPLIST to handle a counter of non-atomic type with its helper functions.
+// OPLIST to handle a counter of non-atomic type
 #define SHAREDI_INTEGER_OPLIST (TYPE(int),                              \
                                 INIT_SET(sharedi_integer_init_set),     \
                                 ADD(sharedi_integer_add),               \
                                 SUB(sharedi_integer_sub),               \
                                 IT_CREF(sharedi_integer_cref))
+
+/* Atomic like interface for basic integers */
 static inline void sharedi_integer_init_set(int *p, int val) { *p = val; }
 static inline int sharedi_integer_add(int *p, int val) { int r = *p;  *p += val; return r; }
 static inline int sharedi_integer_sub(int *p, int val) { int r = *p;  *p -= val; return r; }
 static inline int sharedi_integer_cref(int *p) { return *p; }
 
+/* Contract of a shared pointer */
 #define SHAREDI_CONTRACT(shared, cpt_oplist) do {                       \
     assert(shared != NULL);                                             \
-    assert(*shared == NULL || M_GET_IT_CREF cpt_oplist ( &(*shared)->cpt) >= 1); \
+    assert(*shared == NULL || M_CALL_IT_CREF(cpt_oplist, &(*shared)->cpt) >= 1); \
   } while (0)
 
-#define SHAREDI_PTR_DEF2(name, type, oplist, cpt_oplist)                \
+// deferred evaluation
+#define SHAREDI_PTR_DEF_P1(arg) SHAREDI_PTR_DEF_P2 arg
+
+/* Validate the oplist before going further */
+#define SHAREDI_PTR_DEF_P2(name, type, oplist, cpt_oplist_t)            \
+  M_IF_OPLIST(oplist)(SHAREDI_PTR_DEF_P3, SHAREDI_PTR_DEF_FAILURE)(name, type, oplist, cpt_oplist_t)
+
+/* Stop processing with a compilation failure */
+#define SHAREDI_PTR_DEF_FAILURE(name, type, oplist, cpt_oplist)         \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(SHARED_PTR_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* Code generation */
+#define SHAREDI_PTR_DEF_P3(name, type, oplist, cpt_oplist)              \
 									\
   typedef struct M_C(name, _s){						\
     type *data;	                /* Pointer to the data */               \
     M_GET_TYPE cpt_oplist  cpt; /* Counter of how many points to the data */ \
     bool  combineAlloc; /* Does the data and the ptr share the slot? */ \
   } *M_C(name, _t)[1];							\
+  typedef struct M_C(name, _s) *M_C(name, _ptr);                        \
+  typedef const struct M_C(name, _s) *M_C(name, _srcptr);               \
 		  							\
   typedef struct M_C(name, combine_s) {                                 \
     type data;                                                          \
     struct M_C(name, _s) ptr;						\
   } M_C(name, combine_t)[1];						\
                                                                         \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                      \
+                                                                        \
   static inline void				                        \
   M_C(name, _init)(M_C(name, _t) shared)                                \
   {									\
@@ -134,13 +162,13 @@ static inline int sharedi_integer_cref(int *p) { return *p; }
       *shared = NULL;                                                   \
       return;                                                           \
     }                                                                   \
-    ptr = M_GET_NEW oplist (struct M_C(name, _s));			\
+    ptr = M_CALL_NEW(oplist, struct M_C(name, _s));			\
     if (M_UNLIKELY (ptr == NULL)) {                                     \
       M_MEMORY_FULL(sizeof(struct M_C(name, _s)));			\
       return;                                                           \
     }                                                                   \
     ptr->data = data;							\
-    M_GET_INIT_SET cpt_oplist (&ptr->cpt, 1);                           \
+    M_CALL_INIT_SET(cpt_oplist, &ptr->cpt, 1);                          \
     ptr->combineAlloc = false;                                          \
     *shared = ptr;							\
     SHAREDI_CONTRACT(shared, cpt_oplist);                               \
@@ -151,16 +179,16 @@ static inline int sharedi_integer_cref(int *p) { return *p; }
   {									\
     /* NOTE: Alloc 1 struct with both structures. */                    \
     struct M_C(name, combine_s) *p =					\
-      M_GET_NEW oplist (struct M_C(name, combine_s));			\
+      M_CALL_NEW(oplist, struct M_C(name, combine_s));			\
     if (M_UNLIKELY (p == NULL)) {                                       \
       M_MEMORY_FULL(sizeof(struct M_C(name, combine_s)));		\
       return;								\
     }                                                                   \
     struct M_C(name, _s) *ptr = &p->ptr;				\
     type *data = &p->data;                                              \
-    M_GET_INIT oplist(*data);                                           \
+    M_CALL_INIT( oplist, *data);                                        \
     ptr->data = data;							\
-    M_GET_INIT_SET cpt_oplist (&ptr->cpt, 1);                           \
+    M_CALL_INIT_SET(cpt_oplist, &ptr->cpt, 1);                          \
     ptr->combineAlloc = true;                                           \
     *shared = ptr;							\
     SHAREDI_CONTRACT(shared, cpt_oplist);                               \
@@ -181,7 +209,7 @@ static inline int sharedi_integer_cref(int *p) { return *p; }
     assert (dest != shared);                                            \
     *dest = *shared;							\
     if (*dest != NULL) {						\
-      int n = M_GET_ADD cpt_oplist ( &((*dest)->cpt), 1);               \
+      int n = M_CALL_ADD(cpt_oplist, &((*dest)->cpt), 1);             \
       (void) n;	/* unused return value */				\
     }									\
     SHAREDI_CONTRACT(dest, cpt_oplist);                                 \
@@ -192,16 +220,16 @@ static inline int sharedi_integer_cref(int *p) { return *p; }
   {									\
     SHAREDI_CONTRACT(dest, cpt_oplist);                                 \
     if (*dest != NULL)	{						\
-      if (M_GET_SUB cpt_oplist ( &((*dest)->cpt), 1) == 1)	{       \
+      if (M_CALL_SUB(cpt_oplist, &((*dest)->cpt), 1) == 1)	{       \
         bool combineAlloc = (*dest)->combineAlloc;                      \
         /* Note: if combineAlloc is true, the address of the slot       \
            combining both data & ptr is the same as the address of the  \
            first element, aka data itself. Static analyzer tools don't  \
            seem to detect this and report error. */                     \
-        M_GET_CLEAR oplist (*(*dest)->data);                            \
-        M_GET_DEL oplist ((*dest)->data);                               \
+        M_CALL_CLEAR(oplist, *(*dest)->data);                           \
+        M_CALL_DEL(oplist, (*dest)->data);                              \
         if (combineAlloc == false)                                      \
-          M_GET_DEL oplist (*dest);                                     \
+          M_CALL_DEL(oplist, *dest);                                    \
       }									\
       *dest = NULL;                                                     \
     }                                                                   \
@@ -267,7 +295,7 @@ static inline int sharedi_integer_cref(int *p) { return *p; }
     return *p1 == *p2;							\
   }									\
 									\
-  static inline const type *						\
+  static inline type const *						\
   M_C(name, _cref)(const M_C(name, _t) shared)				\
   {									\
     SHAREDI_CONTRACT(shared, cpt_oplist);                               \
@@ -295,15 +323,23 @@ static inline int sharedi_integer_cref(int *p) { return *p; }
   } while (0)
 
 // deferred
-#define SHAREDI_RESOURCE_DEF(arg) SHAREDI_RESOURCE_DEF2 arg
+#define SHAREDI_RESOURCE_DEF_P1(arg) SHAREDI_RESOURCE_DEF_P2 arg
 
-#define SHAREDI_RESOURCE_DEF2(name, type, oplist)                       \
+/* Validate the oplist before going further */
+#define SHAREDI_RESOURCE_DEF_P2(name, type, oplist)            \
+  M_IF_OPLIST(oplist)(SHAREDI_RESOURCE_DEF_P3, SHAREDI_RESOURCE_DEF_FAILURE)(name, type, oplist)
+
+/* Stop processing with a compilation failure */
+#define SHAREDI_RESOURCE_DEF_FAILURE(name, type, oplist)         \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(SHARED_RESOURCE_DEF): the given argument is not a valid oplist: " #oplist)
+
+#define SHAREDI_RESOURCE_DEF_P3(name, type, oplist)                     \
                                                                         \
   /* Create an aligned type to avoid false sharing between threads */   \
   typedef struct M_C(name, _atype_s) {                                  \
     atomic_uint  cpt;                                                   \
     type         x;							\
-    char align[M_ALIGN_FOR_CACHELINE_EXCLUSION > sizeof(type) +sizeof(atomic_uint) ? M_ALIGN_FOR_CACHELINE_EXCLUSION - sizeof(type) -sizeof(atomic_uint) : 1]; \
+    M_CACHELINE_ALIGN(align, type, atomic_uint);                        \
   } M_C(name, _atype_t);                                                \
                                                                         \
   typedef struct M_C(name, _s) {                                        \
@@ -321,14 +357,14 @@ static inline int sharedi_integer_cref(int *p) { return *p; }
   {                                                                     \
     assert(s != NULL);                                                  \
     assert (n > 0);                                                     \
-    s->buffer = M_GET_REALLOC oplist (M_C(name, _atype_t), NULL, n);    \
+    s->buffer = M_CALL_REALLOC(oplist, M_C(name, _atype_t), NULL, n);   \
     if (M_UNLIKELY (s->buffer == NULL)) {                               \
       M_MEMORY_FULL(sizeof(M_C(name, _atype_t)) * n);                   \
       return;                                                           \
     }                                                                   \
     for(size_t i = 0; i < n; i++) {                                     \
-      M_GET_INIT oplist (s->buffer[i].x);                               \
-      atomic_init (&s->buffer[i].cpt, 0U);                               \
+      M_CALL_INIT(oplist, s->buffer[i].x);                              \
+      atomic_init (&s->buffer[i].cpt, 0U);                              \
     }                                                                   \
     genint_init(s->core, n);                                            \
     SHAREDI_RESOURCE_CONTRACT(s);                                       \
@@ -340,9 +376,9 @@ static inline int sharedi_integer_cref(int *p) { return *p; }
     SHAREDI_RESOURCE_CONTRACT(s);                                       \
     size_t n = genint_size(s->core);                                    \
     for(size_t i = 0; i < n; i++) {                                     \
-      M_GET_CLEAR oplist (s->buffer[i].x);                              \
+      M_CALL_CLEAR(oplist, s->buffer[i].x);                             \
     }                                                                   \
-    M_GET_FREE oplist (s->buffer);                                      \
+    M_CALL_FREE(oplist, s->buffer);                                     \
     s->buffer = NULL;                                                   \
     genint_clear(s->core);                                              \
   }                                                                     \
@@ -355,7 +391,7 @@ static inline int sharedi_integer_cref(int *p) { return *p; }
     unsigned int idx = genint_pop(s->core);                             \
     it->idx = idx;                                                      \
     it->ref = s;                                                        \
-    if (M_LIKELY (idx != -1U)) {                                        \
+    if (M_LIKELY (idx != GENINT_ERROR)) {                               \
       assert(atomic_load(&s->buffer[idx].cpt) == 0);                    \
       atomic_store(&s->buffer[idx].cpt, 1U);                            \
     }                                                                   \
@@ -365,21 +401,21 @@ static inline int sharedi_integer_cref(int *p) { return *p; }
   M_C(name, _end_p)(M_C(name, _it_t) it)                                \
   {                                                                     \
     assert (it != NULL);                                                \
-    return it->idx == -1U;                                              \
+    return it->idx == GENINT_ERROR;                                     \
   }                                                                     \
                                                                         \
   static inline type *                                                  \
   M_C(name, _ref)(M_C(name, _it_t) it)                                  \
   {                                                                     \
-    assert (it != NULL && it->ref != NULL && it->idx != -1U);           \
+    assert (it != NULL && it->ref != NULL && it->idx != GENINT_ERROR);  \
     SHAREDI_RESOURCE_CONTRACT(it->ref);                                 \
     return &it->ref->buffer[it->idx].x;                                 \
   }                                                                     \
                                                                         \
-  static inline const type *                                            \
+  static inline type const *                                            \
   M_C(name, _cref)(M_C(name, _it_t) it)                                 \
   {                                                                     \
-    assert (it != NULL && it->ref != NULL && it->idx != -1U);           \
+    assert (it != NULL && it->ref != NULL && it->idx != GENINT_ERROR);  \
     SHAREDI_RESOURCE_CONTRACT(it->ref);                                 \
     return M_CONST_CAST (type, &it->ref->buffer[it->idx].x);            \
   }                                                                     \
@@ -391,12 +427,12 @@ static inline int sharedi_integer_cref(int *p) { return *p; }
     assert (it != NULL);                                                \
     assert (it->ref == s);                                              \
     unsigned int idx = it->idx;                                         \
-    if (M_LIKELY (idx != -1U)) {                                        \
+    if (M_LIKELY (idx != GENINT_ERROR)) {                               \
       unsigned int c = atomic_fetch_sub (&it->ref->buffer[idx].cpt, 1U); \
       if (c == 1) {                                                     \
         genint_push(it->ref->core, idx);                                \
       }                                                                 \
-      it->idx = -1U;                                                    \
+      it->idx = GENINT_ERROR;                                           \
     }                                                                   \
   }                                                                     \
                                                                         \
@@ -408,7 +444,7 @@ static inline int sharedi_integer_cref(int *p) { return *p; }
     itd->ref = its->ref;                                                \
     unsigned int idx = its->idx;                                        \
     itd->idx = idx;                                                     \
-    if (M_LIKELY (idx != -1U)) {                                        \
+    if (M_LIKELY (idx != GENINT_ERROR)) {                               \
       unsigned int c = atomic_fetch_add(&itd->ref->buffer[idx].cpt, 1U); \
       assert (c >= 1);                                                  \
     }                                                                   \

m-snapshot.h

@@ -1,7 +1,7 @@
 /*
  * M*LIB - SNAPSHOT Module
  *
- * Copyright (c) 2017-2018, Patrick Pelissier
+ * Copyright (c) 2017-2020, 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:
@@ -22,171 +22,192 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#ifndef __M_SNAPSHOT
-#define __M_SNAPSHOT
+#ifndef MSTARLIB_SNAPSHOT
+#define MSTARLIB_SNAPSHOT
 
 #include "m-atomic.h"
 #include "m-core.h"
 #include "m-genint.h"
 
-// For compatibility with previous version
-#define SNAPSHOT_DEF SNAPSHOT_SPSC_DEF
-
-/* Define a SRSW snapshot and it function
+/* Define a Single Producer Single Consummer snapshot and its functions
    USAGE: SNAPSHOT_SPSC_DEF(name, type[, oplist]) */
 #define SNAPSHOT_SPSC_DEF(name, ...)                                    \
-  SNAPSHOTI_SRSW_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
-                     ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__) ), \
-                      (name, __VA_ARGS__ )))
+  SNAPSHOTI_SPSC_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                     \
+                        ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)() ), \
+                         (name, __VA_ARGS__ )))
 
-/* Define a SPMC snapshot and it function
+
+/* Define a Single Producer Multiple Consummer snapshot and its functions
    USAGE: SNAPSHOT_SPMC_DEF(name, type[, oplist]) */
 #define SNAPSHOT_SPMC_DEF(name, ...)                                    \
-  SNAPSHOTI_SPMC_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
-                     ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__) ), \
-                      (name, __VA_ARGS__ )))
+  SNAPSHOTI_SPMC_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                     \
+                        ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)() ), \
+                         (name, __VA_ARGS__ )))
 
-/* Define a MPMC snapshot and it function
+
+/* Define a Multiple Producer Multiple Consummer snapshot and its functions
    USAGE: SNAPSHOT_MPMC_DEF(name, type[, oplist]) */
 #define SNAPSHOT_MPMC_DEF(name, ...)                                    \
-  SNAPSHOTI_MPMC_DEF(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
-                     ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__) ), \
-                      (name, __VA_ARGS__ )))
+  SNAPSHOTI_MPMC_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                     \
+                        ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)() ), \
+                         (name, __VA_ARGS__ )))
 
-/* Define the oplist of a snapshot.
+
+/* Define the oplist of a snapshot (SPSC, SPMC or MPMC).
    USAGE: SNAPSHOT_OPLIST(name[, oplist]) */
 #define SNAPSHOT_OPLIST(...)                                            \
-  SNAPSHOTI_OPLIST(M_IF_NARGS_EQ1(__VA_ARGS__)                          \
-                   ((__VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__) ), \
-                    (__VA_ARGS__ )))
+  SNAPSHOTI_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                       \
+                      ((__VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)() ), \
+                       (__VA_ARGS__ )))
 
 
 /********************************** INTERNAL ************************************/
 
-// deferred
-#define SNAPSHOTI_OPLIST(arg) SNAPSHOTI_OPLIST2 arg
+// deferred evaluation of the input
+#define SNAPSHOTI_OPLIST_P1(arg) SNAPSHOTI_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define SNAPSHOTI_OPLIST_P2(name, oplist)					\
+  M_IF_OPLIST(oplist)(SNAPSHOTI_OPLIST_P3, SNAPSHOTI_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define SNAPSHOTI_OPLIST_FAILURE(name, oplist)		\
+  M_LIB_ERROR(ARGUMENT_OF_SNAPSHOT_OPLIST_IS_NOT_AN_OPLIST, name, oplist)
 
 /* Define the oplist of a snapshot */
-#define SNAPSHOTI_OPLIST2(name, oplist)					\
-  (INIT(M_C(name, _init)),						\
-   INIT_SET(M_C(name, _init_set)),					\
-   SET(M_C(name, _set)),						\
-   CLEAR(M_C(name, _clear)),						\
-   TYPE(M_C(name, _t)),							\
-   SUBTYPE(M_C(name_, type_t))						\
+#define SNAPSHOTI_OPLIST_P3(name, oplist)                               \
+  (INIT(M_C(name, _init))						\
+   ,INIT_SET(M_C(name, _init_set))					\
+   ,SET(M_C(name, _set))						\
+   ,CLEAR(M_C(name, _clear))						\
+   ,TYPE(M_C(name, _t))                                                 \
+   ,SUBTYPE(M_C(name_, type_t))						\
    ,OPLIST(oplist)                                                      \
    ,M_IF_METHOD(INIT_MOVE, oplist)(INIT_MOVE(M_C(name, _init_move)),)	\
    ,M_IF_METHOD(MOVE, oplist)(MOVE(M_C(name, _move)),)			\
    )
 
 
-/******************************** INTERNAL SRSW **********************************/
+/******************************** INTERNAL SPSC **********************************/
 
 /* Flag defining the atomic state of a snapshot:
  * - r: Index of the read buffer Range [0..2]
  * - w: Index of the write buffer  Range [0..2]
  * - f: Next index of the write buffer when a shot is taken Range [0..2]
  * - b: Boolean indicating that the read buffer shall be updated
+ * all fields packed in an unsigned char type.
  */
-#define SNAPSHOTI_SRSW_FLAG(r, w, f, b)					\
+#define SNAPSHOTI_SPSC_FLAG(r, w, f, b)					\
   ((unsigned char)( ( (r) << 4) | ((w) << 2) | ((f)) | ((b) << 6)))
-#define SNAPSHOTI_SRSW_R(flags)			\
+#define SNAPSHOTI_SPSC_R(flags)			\
   (((flags) >> 4) & 0x03u)
-#define SNAPSHOTI_SRSW_W(flags)			\
+#define SNAPSHOTI_SPSC_W(flags)			\
   (((flags) >> 2) & 0x03u)
-#define SNAPSHOTI_SRSW_F(flags)			\
+#define SNAPSHOTI_SPSC_F(flags)			\
   (((flags) >> 0) & 0x03u)
-#define SNAPSHOTI_SRSW_B(flags)			\
+#define SNAPSHOTI_SPSC_B(flags)			\
   (((flags) >> 6) & 0x01u)
 
 /* NOTE: Due to atomic_load only accepting non-const pointer,
    we can't have any const in the interface. */
-#define SNAPSHOTI_SRSW_FLAGS_CONTRACT(flags)                            \
-  assert(SNAPSHOTI_SRSW_R(flags) != SNAPSHOTI_SRSW_W(flags)             \
-	 && SNAPSHOTI_SRSW_R(flags) != SNAPSHOTI_SRSW_F(flags)          \
-	 && SNAPSHOTI_SRSW_W(flags) != SNAPSHOTI_SRSW_F(flags))
-#define SNAPSHOTI_SRSW_CONTRACT(snap)	do {                            \
+#define SNAPSHOTI_SPSC_FLAGS_CONTRACT(flags)                            \
+  assert(SNAPSHOTI_SPSC_R(flags) != SNAPSHOTI_SPSC_W(flags)             \
+	 && SNAPSHOTI_SPSC_R(flags) != SNAPSHOTI_SPSC_F(flags)          \
+	 && SNAPSHOTI_SPSC_W(flags) != SNAPSHOTI_SPSC_F(flags))
+#define SNAPSHOTI_SPSC_CONTRACT(snap)	do {                            \
     assert((snap) != NULL);						\
     unsigned char f = atomic_load (&(snap)->flags);                     \
-    SNAPSHOTI_SRSW_FLAGS_CONTRACT(f);                                   \
+    SNAPSHOTI_SPSC_FLAGS_CONTRACT(f);                                   \
   } while (0)
 
-// Defered evaluation (TBC if it really helps).
-#define SNAPSHOTI_SRSW_DEF(arg)	SNAPSHOTI_SRSW_DEF2 arg
+// A snapshot is basically an atomic triple buffer (Lock Free)
+// between a single producer thread and a single consummer thread.
+#define SNAPSHOTI_SPSC_MAX_BUFFER             3
 
-// This is basically an atomic triple buffer (Lock Free)
-// between a produced thread and a consummer thread.
-#define SNAPSHOTI_SRSW_MAX_BUFFER             3
+// Defered evaluation of the arguments.
+#define SNAPSHOTI_SPSC_DEF_P1(arg)	SNAPSHOTI_SPSC_DEF_P2 arg
 
-#define SNAPSHOTI_SRSW_DEF2(name, type, oplist)				\
+/* Validate the oplist before going further */
+#define SNAPSHOTI_SPSC_DEF_P2(name, type, oplist)            \
+  M_IF_OPLIST(oplist)(SNAPSHOTI_SPSC_DEF_P3, SNAPSHOTI_SPSC_DEF_FAILURE)(name, type, oplist)
+
+/* Stop processing with a compilation failure */
+#define SNAPSHOTI_SPSC_DEF_FAILURE(name, type, oplist)                  \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(SNAPSHOT_SPSC_DEF): the given argument is not a valid oplist: " #oplist)
+
+#define SNAPSHOTI_SPSC_DEF_P3(name, type, oplist)                       \
                                                                         \
   /* Create an aligned type to avoid false sharing between threads */   \
   typedef struct M_C(name, _aligned_type_s) {                           \
     type         x;							\
-    char align[M_ALIGN_FOR_CACHELINE_EXCLUSION > sizeof(type) ? M_ALIGN_FOR_CACHELINE_EXCLUSION - sizeof(type) : 1]; \
+    M_CACHELINE_ALIGN(align, type);                                     \
   } M_C(name, _aligned_type_t);                                         \
                                                                         \
   typedef struct M_C(name, _s) {					\
-    M_C(name, _aligned_type_t)  data[SNAPSHOTI_SRSW_MAX_BUFFER];        \
+    M_C(name, _aligned_type_t)  data[SNAPSHOTI_SPSC_MAX_BUFFER];        \
     atomic_uchar flags;                                                 \
   } M_C(name, _t)[1];							\
+  typedef struct M_C(name, _s) *M_C(name, _ptr);                        \
+  typedef const struct M_C(name, _s) *M_C(name, _srcptr);               \
                                                                         \
   typedef type M_C(name, _type_t);                                      \
                                                                         \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                      \
+                                                                        \
   static inline void M_C(name, _init)(M_C(name, _t) snap)               \
   {									\
     assert(snap != NULL);						\
-    for(int i = 0; i < SNAPSHOTI_SRSW_MAX_BUFFER; i++) {                \
-      M_GET_INIT oplist(snap->data[i].x);                               \
+    for(int i = 0; i < SNAPSHOTI_SPSC_MAX_BUFFER; i++) {                \
+      M_CALL_INIT(oplist, snap->data[i].x);                             \
     }									\
-    atomic_init (&snap->flags, SNAPSHOTI_SRSW_FLAG(0, 1, 2, 0));        \
-    SNAPSHOTI_SRSW_CONTRACT(snap);                                      \
+    atomic_init (&snap->flags, SNAPSHOTI_SPSC_FLAG(0, 1, 2, 0));        \
+    SNAPSHOTI_SPSC_CONTRACT(snap);                                      \
   }									\
                                                                         \
   static inline void M_C(name, _clear)(M_C(name, _t) snap)		\
   {									\
-    SNAPSHOTI_SRSW_CONTRACT(snap);                                      \
-    for(int i = 0; i < SNAPSHOTI_SRSW_MAX_BUFFER; i++) {                \
-      M_GET_CLEAR oplist(snap->data[i].x);				\
+    SNAPSHOTI_SPSC_CONTRACT(snap);                                      \
+    for(int i = 0; i < SNAPSHOTI_SPSC_MAX_BUFFER; i++) {                \
+      M_CALL_CLEAR(oplist, snap->data[i].x);				\
     }									\
   }									\
                                                                         \
   static inline void M_C(name, _init_set)(M_C(name, _t) snap,		\
 					  M_C(name, _t) org)		\
   {									\
-    SNAPSHOTI_SRSW_CONTRACT(org);                                       \
+    SNAPSHOTI_SPSC_CONTRACT(org);                                       \
     assert(snap != NULL && snap != org);				\
-    for(int i = 0; i < SNAPSHOTI_SRSW_MAX_BUFFER; i++) {                \
-      M_GET_INIT_SET oplist(snap->data[i].x, org->data[i].x);		\
+    for(int i = 0; i < SNAPSHOTI_SPSC_MAX_BUFFER; i++) {                \
+      M_CALL_INIT_SET(oplist, snap->data[i].x, org->data[i].x);		\
     }									\
     atomic_init (&snap->flags, atomic_load(&org->flags));		\
-    SNAPSHOTI_SRSW_CONTRACT(snap);                                      \
+    SNAPSHOTI_SPSC_CONTRACT(snap);                                      \
   }									\
                                                                         \
   static inline void M_C(name, _set)(M_C(name, _t) snap,		\
 				     M_C(name, _t) org)			\
   {									\
-    SNAPSHOTI_SRSW_CONTRACT(snap);                                      \
-    SNAPSHOTI_SRSW_CONTRACT(org);                                       \
-    for(int i = 0; i < SNAPSHOTI_SRSW_MAX_BUFFER; i++) {                \
-      M_GET_SET oplist(snap->data[i].x, org->data[i].x);                \
+    SNAPSHOTI_SPSC_CONTRACT(snap);                                      \
+    SNAPSHOTI_SPSC_CONTRACT(org);                                       \
+    for(int i = 0; i < SNAPSHOTI_SPSC_MAX_BUFFER; i++) {                \
+      M_CALL_SET(oplist, snap->data[i].x, org->data[i].x);              \
     }									\
     atomic_init (&snap->flags, atomic_load(&org->flags));		\
-    SNAPSHOTI_SRSW_CONTRACT(snap);                                      \
+    SNAPSHOTI_SPSC_CONTRACT(snap);                                      \
   }									\
                                                                         \
   M_IF_METHOD(INIT_MOVE, oplist)(					\
     static inline void M_C(name, _init_move)(M_C(name, _t) snap,        \
 					     M_C(name, _t) org)		\
     {									\
-      SNAPSHOTI_SRSW_CONTRACT(org);                                     \
+      SNAPSHOTI_SPSC_CONTRACT(org);                                     \
       assert(snap != NULL && snap != org);				\
-      for(int i = 0; i < SNAPSHOTI_SRSW_MAX_BUFFER; i++) {              \
-	M_GET_INIT_MOVE oplist(snap->data[i].x, org->data[i].x);        \
+      for(int i = 0; i < SNAPSHOTI_SPSC_MAX_BUFFER; i++) {              \
+	M_CALL_INIT_MOVE(oplist, snap->data[i].x, org->data[i].x);      \
       }									\
       atomic_store (&snap->flags, atomic_load(&org->flags));            \
-      atomic_store (&org->flags, SNAPSHOTI_SRSW_FLAG(0,0,0,0) );        \
-      SNAPSHOTI_SRSW_CONTRACT(snap);                                    \
+      atomic_store (&org->flags, SNAPSHOTI_SPSC_FLAG(0,0,0,0) );        \
+      SNAPSHOTI_SPSC_CONTRACT(snap);                                    \
     }									\
     ,) /* IF_METHOD (INIT_MOVE) */					\
                                                                         \
@@ -194,82 +215,83 @@
      static inline void M_C(name, _move)(M_C(name, _t) snap,            \
 					 M_C(name, _t) org)		\
      {									\
-       SNAPSHOTI_SRSW_CONTRACT(snap);					\
-       SNAPSHOTI_SRSW_CONTRACT(org);                                    \
+       SNAPSHOTI_SPSC_CONTRACT(snap);					\
+       SNAPSHOTI_SPSC_CONTRACT(org);                                    \
        assert(snap != org);						\
-       for(int i = 0; i < SNAPSHOTI_SRSW_MAX_BUFFER; i++) {             \
-	 M_GET_MOVE oplist(snap->data[i].x, org->data[i].x);		\
+       for(int i = 0; i < SNAPSHOTI_SPSC_MAX_BUFFER; i++) {             \
+	 M_CALL_MOVE(oplist, snap->data[i].x, org->data[i].x);		\
        }								\
        atomic_store (&snap->flags, atomic_load(&org->flags));           \
-       atomic_store (&org->flags, SNAPSHOTI_SRSW_FLAG(0,0,0,0) );       \
-       SNAPSHOTI_SRSW_CONTRACT(snap);					\
+       atomic_store (&org->flags, SNAPSHOTI_SPSC_FLAG(0,0,0,0) );       \
+       SNAPSHOTI_SPSC_CONTRACT(snap);					\
      }									\
      ,) /* IF_METHOD (MOVE) */						\
                                                                         \
                                                                         \
   static inline type *M_C(name, _write)(M_C(name, _t) snap)             \
   {									\
-    SNAPSHOTI_SRSW_CONTRACT(snap);                                      \
+    SNAPSHOTI_SPSC_CONTRACT(snap);                                      \
     unsigned char nextFlags, origFlags = atomic_load (&snap->flags);	\
     /* Atomic CAS operation */                                          \
     do {								\
       /* Swap F and W buffer, setting exchange flag */                  \
-      nextFlags = SNAPSHOTI_SRSW_FLAG(SNAPSHOTI_SRSW_R(origFlags),      \
-                                      SNAPSHOTI_SRSW_F(origFlags),      \
-                                      SNAPSHOTI_SRSW_W(origFlags), 1);  \
+      nextFlags = SNAPSHOTI_SPSC_FLAG(SNAPSHOTI_SPSC_R(origFlags),      \
+                                      SNAPSHOTI_SPSC_F(origFlags),      \
+                                      SNAPSHOTI_SPSC_W(origFlags), 1);  \
       /* exponential backoff is not needed as there can't be more       \
          than 2 threads which try to update the data. */                \
     } while (!atomic_compare_exchange_weak (&snap->flags, &origFlags,	\
 					    nextFlags));		\
     /* Return new write buffer for new updating */                      \
-    return &snap->data[SNAPSHOTI_SRSW_W(nextFlags)].x;                  \
+    return &snap->data[SNAPSHOTI_SPSC_W(nextFlags)].x;                  \
   }									\
                                                                         \
-  static inline const type *M_C(name, _read)(M_C(name, _t) snap)	\
+  static inline type const *M_C(name, _read)(M_C(name, _t) snap)	\
   {									\
-    SNAPSHOTI_SRSW_CONTRACT(snap);                                      \
+    SNAPSHOTI_SPSC_CONTRACT(snap);                                      \
     unsigned char nextFlags, origFlags = atomic_load (&snap->flags);	\
     /* Atomic CAS operation */                                          \
     do {								\
       /* If no exchange registered, do nothing and keep the same */     \
-      if (!SNAPSHOTI_SRSW_B(origFlags)) {                               \
+      if (!SNAPSHOTI_SPSC_B(origFlags)) {                               \
         nextFlags = origFlags;                                          \
 	break;								\
       }                                                                 \
       /* Swap R and F buffer, clearing exchange flag */                 \
-      nextFlags = SNAPSHOTI_SRSW_FLAG(SNAPSHOTI_SRSW_F(origFlags),      \
-                                      SNAPSHOTI_SRSW_W(origFlags),      \
-                                      SNAPSHOTI_SRSW_R(origFlags), 0);  \
+      nextFlags = SNAPSHOTI_SPSC_FLAG(SNAPSHOTI_SPSC_F(origFlags),      \
+                                      SNAPSHOTI_SPSC_W(origFlags),      \
+                                      SNAPSHOTI_SPSC_R(origFlags), 0);  \
       /* exponential backoff is not needed as there can't be more       \
          than 2 threads which try to update the data. */                \
     } while (!atomic_compare_exchange_weak (&snap->flags, &origFlags,	\
 					    nextFlags));		\
     /* Return current read buffer */                                    \
-    return M_CONST_CAST(type, &snap->data[SNAPSHOTI_SRSW_R(nextFlags)].x); \
+    return M_CONST_CAST(type, &snap->data[SNAPSHOTI_SPSC_R(nextFlags)].x); \
   }									\
                                                                         \
   static inline bool M_C(name, _updated_p)(M_C(name, _t) snap)          \
   {									\
-    SNAPSHOTI_SRSW_CONTRACT(snap);                                      \
+    SNAPSHOTI_SPSC_CONTRACT(snap);                                      \
     unsigned char flags = atomic_load (&snap->flags);                   \
-    return SNAPSHOTI_SRSW_B(flags);                                     \
+    return SNAPSHOTI_SPSC_B(flags);                                     \
   }									\
                                                                         \
   static inline type *M_C(name, _get_write_buffer)(M_C(name, _t) snap)	\
   {									\
-    SNAPSHOTI_SRSW_CONTRACT(snap);                                      \
+    SNAPSHOTI_SPSC_CONTRACT(snap);                                      \
     unsigned char flags = atomic_load(&snap->flags);			\
-    return &snap->data[SNAPSHOTI_SRSW_W(flags)].x;                      \
+    return &snap->data[SNAPSHOTI_SPSC_W(flags)].x;                      \
   }									\
                                                                         \
-  static inline const type *M_C(name, _get_read_buffer)(M_C(name, _t) snap) \
+  static inline type const *M_C(name, _get_read_buffer)(M_C(name, _t) snap) \
   {									\
-    SNAPSHOTI_SRSW_CONTRACT(snap);                                      \
+    SNAPSHOTI_SPSC_CONTRACT(snap);                                      \
     unsigned char flags = atomic_load(&snap->flags);			\
-    return  M_CONST_CAST(type, &snap->data[SNAPSHOTI_SRSW_R(flags)].x);	\
+    return  M_CONST_CAST(type, &snap->data[SNAPSHOTI_SPSC_R(flags)].x);	\
   }									\
   
 
+
 /******************************** INTERNAL SPMC **********************************/
 
 #define SNAPSHOTI_SPMC_INT_FLAG(w, n) ( ((w) << 1) | (n) )
@@ -279,10 +301,15 @@
 // 2 more buffer than the number of readers are needed
 #define SNAPSHOTI_SPMC_EXTRA_BUFFER 2
 
-// due to genint
-#define SNAPSHOTI_SPMC_MAX_READER (4096-SNAPSHOTI_SPMC_EXTRA_BUFFER)
+#define SNAPSHOTI_SPMC_MAX_READER (GENINT_MAX_ALLOC-SNAPSHOTI_SPMC_EXTRA_BUFFER)
 
-// structure to handle SPMC snapshot but return a unique index in a buffer array.
+/* structure to handle SPMC snapshot but return an unique index in the buffer array.
+   - lastNext: last published written index + next flag (format SNAPSHOTI_SPMC_INT_FLAG)
+   - currentWrite: the index being currently written.
+   - n : number of readers 
+   - cptTab: ref counter array
+   - freeList: a pool of free integers.
+*/
 typedef struct snapshot_mrsw_int_s {
   atomic_uint lastNext;
   unsigned int currentWrite;
@@ -295,7 +322,7 @@ typedef struct snapshot_mrsw_int_s {
 #define SNAPSHOTI_SPMC_INT_CONTRACT(s) do {                             \
     assert (s != NULL);                                                 \
     assert (s->n > 0 && s->n <= SNAPSHOTI_SPMC_MAX_READER);             \
-    assert (SNAPSHOTI_SPMC_INT_FLAG_W(atomic_load(&s->lastNext))        \
+    assert ((size_t)SNAPSHOTI_SPMC_INT_FLAG_W(atomic_load(&s->lastNext)) \
             <= s->n + SNAPSHOTI_SPMC_EXTRA_BUFFER);                     \
     assert (s->cptTab != NULL);                                         \
   } while (0)
@@ -317,12 +344,12 @@ static inline void snapshot_mrsw_int_init(snapshot_mrsw_int_t s, size_t n)
   genint_init (s->freeList, n);
   // Get a free buffer and set it as available for readers
   unsigned int w = genint_pop(s->freeList);
-  assert (w != -1U);
+  assert (w != GENINT_ERROR);
   atomic_store(&s->cptTab[w], 1U);
   atomic_init(&s->lastNext, SNAPSHOTI_SPMC_INT_FLAG(w, true));
   // Get working buffer
   s->currentWrite = genint_pop(s->freeList);
-  assert (s->currentWrite != -1U);
+  assert (s->currentWrite != GENINT_ERROR);
   atomic_store(&s->cptTab[s->currentWrite], 1U);
   SNAPSHOTI_SPMC_INT_CONTRACT(s);
 }
@@ -342,6 +369,12 @@ static inline unsigned int snapshot_mrsw_int_get_write_idx(snapshot_mrsw_int_t s
   return s->currentWrite;
 }
 
+static inline unsigned int snapshot_mrsw_int_size(snapshot_mrsw_int_t s)
+{
+  SNAPSHOTI_SPMC_INT_CONTRACT(s);
+  return s->n;
+}
+
 static inline unsigned int snapshot_mrsw_int_write_idx(snapshot_mrsw_int_t s, unsigned int idx)
 {
   SNAPSHOTI_SPMC_INT_CONTRACT(s);
@@ -365,8 +398,7 @@ static inline unsigned int snapshot_mrsw_int_write_idx(snapshot_mrsw_int_t s, un
       // If someone else keeps a ref on the buffer, we can't reuse it
       // get another free one.
       idx = genint_pop(s->freeList);
-      // TODO: sometimes fails...
-      assert(idx != -1U);
+      assert(idx != GENINT_ERROR);
     }
     assert (idx < s->n + SNAPSHOTI_SPMC_EXTRA_BUFFER);
     assert (atomic_load(&s->cptTab[idx]) == 0);
@@ -388,7 +420,7 @@ static inline unsigned int snapshot_mrsw_int_write_start(snapshot_mrsw_int_t s)
   SNAPSHOTI_SPMC_INT_CONTRACT(s);
   // Get a new buffer.
   unsigned int idx = genint_pop(s->freeList);
-  assert (idx != -1U);
+  assert (idx != GENINT_ERROR);
   assert (idx < s->n + SNAPSHOTI_SPMC_EXTRA_BUFFER);
   assert (atomic_load(&s->cptTab[idx]) == 0);
   atomic_store(&s->cptTab[idx], 1U);
@@ -476,15 +508,23 @@ static inline void snapshot_mrsw_int_read_end(snapshot_mrsw_int_t s, unsigned in
   } while (0)
 
 
-// Defered evaluation (TBC if it really helps).
-#define SNAPSHOTI_SPMC_DEF(arg)	SNAPSHOTI_SPMC_DEF2 arg
+// Defered evaluation
+#define SNAPSHOTI_SPMC_DEF_P1(arg)	SNAPSHOTI_SPMC_DEF_P2 arg
 
-#define SNAPSHOTI_SPMC_DEF2(name, type, oplist)                         \
+/* Validate the oplist before going further */
+#define SNAPSHOTI_SPMC_DEF_P2(name, type, oplist)            \
+  M_IF_OPLIST(oplist)(SNAPSHOTI_SPMC_DEF_P3, SNAPSHOTI_SPMC_DEF_FAILURE)(name, type, oplist)
+
+/* Stop processing with a compilation failure */
+#define SNAPSHOTI_SPMC_DEF_FAILURE(name, type, oplist)                  \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(SNAPSHOT_SPMC_DEF): the given argument is not a valid oplist: " #oplist)
+
+#define SNAPSHOTI_SPMC_DEF_P3(name, type, oplist)                       \
                                                                         \
   /* Create an aligned type to avoid false sharing between threads */   \
   typedef struct M_C(name, _aligned_type_s) {                           \
     type         x;							\
-    char align[M_ALIGN_FOR_CACHELINE_EXCLUSION > sizeof(type) ? M_ALIGN_FOR_CACHELINE_EXCLUSION - sizeof(type) : 1]; \
+    M_CACHELINE_ALIGN(align, type);                                     \
   } M_C(name, _aligned_type_t);                                         \
                                                                         \
   typedef struct M_C(name, _s) {					\
@@ -494,20 +534,21 @@ static inline void snapshot_mrsw_int_read_end(snapshot_mrsw_int_t s, unsigned in
                                                                         \
   typedef type M_C(name, _type_t);                                      \
                                                                         \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                      \
+                                                                        \
   static inline void M_C(name, _init)(M_C(name, _t) snap, size_t nReader) \
   {									\
     assert (snap != NULL);						\
     assert (nReader > 0 && nReader <= SNAPSHOTI_SPMC_MAX_READER);       \
-    snap->data = M_GET_REALLOC oplist (M_C(name, _aligned_type_t),      \
-                                       NULL,                            \
-                                       nReader+SNAPSHOTI_SPMC_EXTRA_BUFFER); \
+    snap->data = M_CALL_REALLOC(oplist, M_C(name, _aligned_type_t),     \
+                                NULL, nReader+SNAPSHOTI_SPMC_EXTRA_BUFFER); \
     if (M_UNLIKELY (snap->data == NULL)) {                              \
       M_MEMORY_FULL(sizeof(M_C(name, _aligned_type_t)) *                \
                     (nReader+SNAPSHOTI_SPMC_EXTRA_BUFFER));             \
       return;                                                           \
     }                                                                   \
     for(size_t i = 0; i < nReader + SNAPSHOTI_SPMC_EXTRA_BUFFER; i++) { \
-      M_GET_INIT oplist(snap->data[i].x);                               \
+      M_CALL_INIT(oplist, snap->data[i].x);                             \
     }									\
     snapshot_mrsw_int_init(snap->core, nReader);                        \
     SNAPSHOTI_SPMC_CONTRACT(snap);                                      \
@@ -516,10 +557,11 @@ static inline void snapshot_mrsw_int_read_end(snapshot_mrsw_int_t s, unsigned in
   static inline void M_C(name, _clear)(M_C(name, _t) snap)		\
   {									\
     SNAPSHOTI_SPMC_CONTRACT(snap);                                      \
-    for(int i = 0; i < SNAPSHOTI_SRSW_MAX_BUFFER; i++) {                \
-      M_GET_CLEAR oplist(snap->data[i].x);				\
+    size_t nReader = snapshot_mrsw_int_size(snap->core);                \
+    for(size_t i = 0; i < nReader + SNAPSHOTI_SPMC_EXTRA_BUFFER; i++) { \
+      M_CALL_CLEAR(oplist, snap->data[i].x);				\
     }									\
-    M_GET_FREE oplist (snap->data);                                     \
+    M_CALL_FREE(oplist, snap->data);                                    \
     snapshot_mrsw_int_clear(snap->core);                                \
   }									\
                                                                         \
@@ -530,14 +572,14 @@ static inline void snapshot_mrsw_int_read_end(snapshot_mrsw_int_t s, unsigned in
     return &snap->data[idx].x;                                          \
   }									\
                                                                         \
-  static inline const type *M_C(name, _read_start)(M_C(name, _t) snap)	\
+  static inline type const *M_C(name, _read_start)(M_C(name, _t) snap)	\
   {									\
     SNAPSHOTI_SPMC_CONTRACT(snap);                                      \
     const unsigned int idx = snapshot_mrsw_int_read_start(snap->core);  \
     return M_CONST_CAST(type, &snap->data[idx].x);                      \
   }									\
                                                                         \
-  static inline void M_C(name, _read_end)(M_C(name, _t) snap, const type *old) \
+  static inline void M_C(name, _read_end)(M_C(name, _t) snap, type const *old) \
   {									\
     SNAPSHOTI_SPMC_CONTRACT(snap);                                      \
     assert (old != NULL);                                               \
@@ -556,19 +598,29 @@ static inline void snapshot_mrsw_int_read_end(snapshot_mrsw_int_t s, unsigned in
     return &snap->data[idx].x;                                          \
   }									\
                                                                         \
-  //TODO: _set_, _init_set
+
+//FIXME: Evaluate the needs for the methods _set_, _init_set.
+
 
 
 /******************************** INTERNAL MPMC **********************************/
 
 // MPMC is built upon SPMC
 
-// Defered evaluation (TBC if it really helps).
-#define SNAPSHOTI_MPMC_DEF(arg)	SNAPSHOTI_MPMC_DEF2 arg
+// Defered evaluation
+#define SNAPSHOTI_MPMC_DEF_P1(arg)	SNAPSHOTI_MPMC_DEF_P2 arg
 
-#define SNAPSHOTI_MPMC_DEF2(name, type, oplist)                         \
+/* Validate the oplist before going further */
+#define SNAPSHOTI_MPMC_DEF_P2(name, type, oplist)            \
+  M_IF_OPLIST(oplist)(SNAPSHOTI_MPMC_DEF_P3, SNAPSHOTI_MPMC_DEF_FAILURE)(name, type, oplist)
+
+/* Stop processing with a compilation failure */
+#define SNAPSHOTI_MPMC_DEF_FAILURE(name, type, oplist)                  \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(SNAPSHOT_MPMC_DEF): the given argument is not a valid oplist: " #oplist)
+
+#define SNAPSHOTI_MPMC_DEF_P3(name, type, oplist)                       \
                                                                         \
-  SNAPSHOTI_SPMC_DEF((M_C(name, _mrsw), type, oplist))                  \
+  SNAPSHOTI_SPMC_DEF_P1((M_C(name, _mrsw), type, oplist))               \
                                                                         \
   typedef struct M_C(name, _s) {					\
     M_C(name, _mrsw_t)  core;                                           \
@@ -576,11 +628,13 @@ static inline void snapshot_mrsw_int_read_end(snapshot_mrsw_int_t s, unsigned in
                                                                         \
   typedef type M_C(name, _type_t);                                      \
                                                                         \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                      \
+                                                                        \
   static inline void M_C(name, _init)(M_C(name, _t) snap, size_t nReader, size_t nWriter) \
   {									\
     M_C(name, _mrsw_init)(snap->core, nReader + nWriter -1 );           \
     unsigned int idx = snap->core->core->currentWrite;                  \
-    snap->core->core->currentWrite = -1;                                \
+    snap->core->core->currentWrite = GENINT_ERROR;                      \
     snapshot_mrsw_int_write_end(snap->core->core, idx);                 \
   }									\
                                                                         \
@@ -607,12 +661,12 @@ static inline void snapshot_mrsw_int_read_end(snapshot_mrsw_int_t s, unsigned in
     snapshot_mrsw_int_write_end(snap->core->core, idx);                 \
   }									\
                                                                         \
-  static inline const type *M_C(name, _read_start)(M_C(name, _t) snap)	\
+  static inline type const *M_C(name, _read_start)(M_C(name, _t) snap)	\
   {									\
     return M_C(name, _mrsw_read_start)(snap->core);                     \
   }									\
                                                                         \
-  static inline void M_C(name, _read_end)(M_C(name, _t) snap, const type *old) \
+  static inline void M_C(name, _read_end)(M_C(name, _t) snap, type const *old) \
   {									\
     M_C(name, _mrsw_read_end)(snap->core, old);                         \
   }									\