Refactor enumerable_thread_specific

change building behavior for gcc 4.8.5

Now, thread id of each thread is also an index to persistent storage
for enumerbale_thread_specific (this index is the same for all
instances of enumerable_thread_specifc which certain thread uses).

This change means that persistent storage can be bigger than neccesary
in some cases (it must be as big as largest 'thread id + 1'). This
implementation also allowed for removal of read lock in local() method.
Now, it's enough to check atomic size variable and if size < thread id
just return element with this index.

This commit also removes local(bool) method beacuse it's not possible to
tell whether certain element existed before or not.

* Replace v<> with volatile_state

* Use std::shared_lock and std::unique_lock instead of
  hand made scoped_lock

* Implement custom thread_id assigning mechanism so that slots in
  persistent storage can be reused after a thread exited

This is needed for enumerable_thread_specific tests
in which we need guarantee on number of threads executing
simultaneously.

Add SCRIPT parameter to add_test_generic()

detect if volatile_state is supported

force isntall containers, even if container tests are disabled

gcc 4.8.5 supports C++11 but does not support expanding variadic
template in lambda expression. If you want to build libpmemobj-cpp with
gcc 4.8.5 you must disable building and installing containers by setting
flag ENABLE_CONTAINERS=OFF

Fix hash map erase deadlock

Add doxygen comments describing namespaces

Update version of PMDK in vcpkg

Update version of PMDK in vcpkg
in order to have the defragmentation feature
(change corresponding to commit bd646ca1).

Update version of PMDK in Docker images

Update version of PMDK in Docker images
in order to have the defragmentation feature.

pandoc is required by the newest PMDK.

It makes possible to use a cmake script from a different test
and prevents from adding the same cmake script for many tests.

Consider the following scenario (where A and B are in the same bucket):
thread 1:		thread 2:
find(acc1, A)
			erase(A)
find(acc2, B)

First, thread 1 takes lock on the bucket and then on element A.
Then, thread 2 takes a lock on the bucket and tries to lock element A
but it can't because thread 1 already locked it - this way thread 2 is blocked.
Next, thread 1 tries to lock the bucket but it can't because thread 2 holds it.
Neither thread can progress.

This patch fixes that by introducing the same algorithm as in lookup/insert.
When trying to lock element in erase we now spin in a loop doing try_acquire and
if we do not succeed after specified amount of time we drop bucket lock and try
whole operation again.

move checking compiling issues from CMakeLists.txt to
check_compiling_issues.cmake (previous name check_compiler_issues.cmake)

Even if we are ensuring that we use CMAKE_CXX_STANDARD >= 14,
check if shared_mutex header file is available for the current
compiler version because CXX_STANDARD is being set to 14 for
--c++1y parameter. Introduce flag to check if volatile_state is
supported.

remove dependency to containers in ptr test

Pass TESTS_TBB environment variable to Docker

Remove checking for offsetof error in pmdk

Add TESTS_TBB cmake option

Rename get_program_version to get_program_version_major_minor

Now, we do not include any headers which depend on offsetof (types.h)
so this check is not longer necessary.

Merge changes from stable 1.8

... because it does not get the patch part of the version any more.

add TESTS_TBB cmake option to enable/disable(by default) tests which
require Intel TBB library and add tbb to windows tests

Merge stable 1.7 into stable 1.8

Fix minor comments issues

volatile_state: add missing include