Remove duplicated host buffer implementations from oneDPL code

[SergeyKopienko]

The goals of this PR:

• to have only one implementation of host __buffer for all backend (serial, tbb and omp) due avoid code duplications.

At this moment our three implementations of host __buffer is absolutly the same excepting the allocators, which they are using:

• serial backend implementation - using std::allocator;
• tbb backend implementation - using tbb::tbb_allocator;
• omp backend implementation - using std::allocator.

In this PR we are not going to break these rules, but will specify using allocator by additional template param of `__buffer' implementation class.

Implementation details

Now we have only one class __buffer_impl in oneDPL code and it's renamed to class __buffer_impl_host:

template <typename _ExecutionPolicy, typename _Tp, typename _TAllocator>
class __buffer_impl_host
{
    // ...
};

The definition of __buffer template alias inside each of host backends looks like

template <typename _BackendOrDispatchTag, typename _ExecutionPolicy, typename _Tp,
          typename _TAllocator = typename oneapi::dpl::__internal::__backend_buffer_allocator_selector<
              _Tp, _BackendOrDispatchTag>::allocator_type>
using __buffer = oneapi::dpl::__utils::__buffer_impl_host<::std::decay_t<_ExecutionPolicy>, _Tp, _TAllocator>;

One important detail here - in the template param _BackendOrDispatchTag we are ready to receive:

• our host backend tags: __serial_backend_tag, __tbb_backend_tag and __omp_backend_tag;
• our host dispatch tags: __serial_tag, __parallel_tag and __parallel_forward_tag.

Also now we can specify which allocator we will use in this buffer through template param _TAllocator :

• for serial and omp backends it's ::std::allocator;
• for tbb backend it's tbb::tbb_allocator.

For support tag dispatching and use different allocators the the host buffer now we using the type allocator_type from __backend_buffer_allocator_selector structure specializations :

template <typename _T>
struct __backend_buffer_allocator_selector<_T, oneapi::dpl::__internal::__serial_backend_tag>
{
    using allocator_type = ::std::allocator<_T>;
};

template <typename _T>
struct __backend_buffer_allocator_selector<_T, oneapi::dpl::__internal::__omp_backend_tag>
{
    using allocator_type = ::std::allocator<_T>;
};

template <typename _T>
struct __backend_buffer_allocator_selector<_T, oneapi::dpl::__internal::__tbb_backend_tag>
{
    using allocator_type = tbb::tbb_allocator<_T>;
};

This structure __backend_buffer_allocator_selector also has specializations for resolve dispatching tags into buffer allocators:

template <typename _T, typename _IsVector>
struct __backend_buffer_allocator_selector<_T, oneapi::dpl::__internal::__serial_tag<_IsVector>>
{
    using allocator_type = ::std::allocator<_T>;
};

template <typename _T, typename _IsVector>
struct __backend_buffer_allocator_selector<_T, oneapi::dpl::__internal::__parallel_tag<_IsVector>>
{
    using allocator_type = typename __backend_buffer_allocator_selector<
        _T, typename oneapi::dpl::__internal::__parallel_tag<_IsVector>::__backend_tag>::allocator_type;
};

template <typename _T>
struct __backend_buffer_allocator_selector<_T, oneapi::dpl::__internal::__parallel_forward_tag>
{
    using allocator_type = typename __backend_buffer_allocator_selector<
        _T, typename oneapi::dpl::__internal::__parallel_forward_tag::__backend_tag>::allocator_type;
};

As result now we have only one implementation of host __buffer with different using allocators which depends on or .

[SergeyKopienko]

Required additional design work.