Index: include/pstl/internal/algorithm_impl.h
===================================================================
--- include/pstl/internal/algorithm_impl.h
+++ include/pstl/internal/algorithm_impl.h
@@ -1029,8 +1029,8 @@
     const _DifferenceType __n = __last - __first;
     if (_DifferenceType(1) < __n)
     {
-        par_backend::buffer<bool> __mask_buf(__n);
-        return except_handler([&__exec, __n, __first, __result, __is_vector, __pred, &__mask_buf]() {
+        par_backend::buffer<bool> __mask_buf(std::forward<_ExecutionPolicy>(__exec), __n);
+        return except_handler([&__exec, __n, __first, __last, __result, __is_vector, __pred, &__mask_buf]() {
             bool* __mask = __mask_buf.get();
             _DifferenceType __m{};
             par_backend::parallel_strict_scan(
@@ -1140,7 +1140,7 @@
     typedef typename std::iterator_traits<_ForwardIterator>::difference_type _DifferenceType;
     typedef typename std::iterator_traits<_ForwardIterator>::value_type _Tp;
     _DifferenceType __n = __last - __first;
-    par_backend::buffer<bool> __mask_buf(__n);
+    par_backend::buffer<bool> __mask_buf(std::forward<_ExecutionPolicy>(__exec), __n);
     // 1. find a first iterator that should be removed
     return except_handler([&]() {
         bool* __mask = __mask_buf.get();
@@ -1177,7 +1177,7 @@
         __n -= __min;
         __first += __min;
 
-        par_backend::buffer<_Tp> __buf(__n);
+        par_backend::buffer<_Tp> __buf(std::forward<_ExecutionPolicy>(__exec), __n);
         _Tp* __result = __buf.get();
         __mask += __min;
         _DifferenceType __m{};
@@ -1303,7 +1303,7 @@
     const _DifferenceType __n = __last - __first;
     if (_DifferenceType(2) < __n)
     {
-        par_backend::buffer<bool> __mask_buf(__n);
+        par_backend::buffer<bool> __mask_buf(std::forward<_ExecutionPolicy>(__exec), __n);
         if (_DifferenceType(2) < __n)
         {
             return internal::except_handler([&__exec, __n, __first, __result, __pred, __is_vector, &__mask_buf]() {
@@ -1541,7 +1541,7 @@
     auto __m = __middle - __first;
     if (__m <= __n / 2)
     {
-        par_backend::buffer<_Tp> __buf(__n - __m);
+        par_backend::buffer<_Tp> __buf(std::forward<_ExecutionPolicy>(__exec), __n - __m);
         return except_handler([&__exec, __n, __m, __first, __middle, __last, __is_vector, &__buf]() {
             _Tp* __result = __buf.get();
             par_backend::parallel_for(
@@ -1566,7 +1566,7 @@
     }
     else
     {
-        par_backend::buffer<_Tp> __buf(__m);
+        par_backend::buffer<_Tp> __buf(std::forward<_ExecutionPolicy>(__exec), __m);
         return except_handler([&__exec, __n, __m, __first, __middle, __last, __is_vector, &__buf]() {
             _Tp* __result = __buf.get();
             par_backend::parallel_for(
@@ -2028,7 +2028,7 @@
     const _DifferenceType __n = __last - __first;
     if (_DifferenceType(1) < __n)
     {
-        par_backend::buffer<bool> __mask_buf(__n);
+        par_backend::buffer<bool> __mask_buf(std::forward<_ExecutionPolicy>(__exec), __n);
         return internal::except_handler(
             [&__exec, __n, __first, __out_true, __out_false, __is_vector, __pred, &__mask_buf]() {
                 bool* __mask = __mask_buf.get();
@@ -2195,7 +2195,7 @@
         {
             typedef typename std::iterator_traits<_ForwardIterator>::value_type _T1;
             typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _T2;
-            par_backend::buffer<_T1> __buf(__n1);
+            par_backend::buffer<_T1> __buf(std::forward<_ExecutionPolicy>(__exec), __n1);
             _T1* __r = __buf.get();
 
             par_backend::parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n1, __comp,
@@ -2661,7 +2661,7 @@
     }
     typedef typename std::iterator_traits<_BidirectionalIterator>::value_type _Tp;
     auto __n = __last - __first;
-    par_backend::buffer<_Tp> __buf(__n);
+    par_backend::buffer<_Tp> __buf(std::forward<_ExecutionPolicy>(__exec), __n);
     _Tp* __r = __buf.get();
     except_handler([&]() {
         auto __move_values = [](_BidirectionalIterator __x, _Tp* __z) {
@@ -2787,7 +2787,7 @@
     const _DifferenceType __n1 = __last1 - __first1;
     const _DifferenceType __n2 = __last2 - __first2;
 
-    par_backend::buffer<_T> __buf(__size_func(__n1, __n2));
+    par_backend::buffer<_T> __buf(std::forward<_ExecutionPolicy>(__exec), __size_func(__n1, __n2));
 
     return except_handler([&__exec, __n1, __first1, __last1, __first2, __last2, __result, __is_vector, __comp,
                            __size_func, __set_op, &__buf]() {
Index: include/pstl/internal/parallel_backend_tbb.h
===================================================================
--- include/pstl/internal/parallel_backend_tbb.h
+++ include/pstl/internal/parallel_backend_tbb.h
@@ -51,7 +51,8 @@
 
   public:
     //! Try to obtain buffer of given size to store objects of _Tp type
-    buffer(std::size_t n) : _M_allocator(), _M_ptr(_M_allocator.allocate(n)), _M_buf_size(n) {}
+    template <typename _ExecutionPolicy>
+    buffer(_ExecutionPolicy&&, std::size_t __n) : _M_allocator(), _M_ptr(_M_allocator.allocate(__n)), _M_buf_size(__n) {}
     //! True if buffer was successfully obtained, zero otherwise.
     operator bool() const { return _M_ptr != NULL; }
     //! Return pointer to buffer, or  NULL if buffer could not be obtained.
@@ -349,16 +350,16 @@
 // T must have a trivial constructor and destructor.
 template <class _ExecutionPolicy, typename _Index, typename _Tp, typename _Rp, typename _Cp, typename _Sp, typename _Ap>
 void
-parallel_strict_scan(_ExecutionPolicy&&, _Index __n, _Tp __initial, _Rp __reduce, _Cp __combine, _Sp __scan, _Ap __apex)
+parallel_strict_scan(_ExecutionPolicy&& __exec, _Index __n, _Tp __initial, _Rp __reduce, _Cp __combine, _Sp __scan, _Ap __apex)
 {
-    tbb::this_task_arena::isolate([=, &__combine]() {
+    tbb::this_task_arena::isolate([=, &__exec, &__combine]() {
         if (__n > 1)
         {
             _Index __p = tbb::this_task_arena::max_concurrency();
             const _Index __slack = 4;
             _Index __tilesize = (__n - 1) / (__slack * __p) + 1;
             _Index __m = (__n - 1) / __tilesize;
-            buffer<_Tp> __buf(__m + 1);
+            buffer<_Tp> __buf(std::forward<_ExecutionPolicy>(__exec), __m + 1);
             _Tp* __r = __buf.get();
             par_backend::upsweep(_Index(0), _Index(__m + 1), __tilesize, __r, __n - __m * __tilesize, __reduce,
                                  __combine);
@@ -578,10 +579,10 @@
 
 template <class _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _LeafSort>
 void
-parallel_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __xs, _RandomAccessIterator __xe, _Compare __comp,
+parallel_stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __xs, _RandomAccessIterator __xe, _Compare __comp,
                      _LeafSort __leaf_sort, std::size_t __nsort = 0)
 {
-    tbb::this_task_arena::isolate([=, &__nsort]() {
+    tbb::this_task_arena::isolate([=, &__exec, &__nsort]() {
         //sorting based on task tree and parallel merge
         typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _ValueType;
         typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
@@ -593,7 +594,7 @@
         if (__n > __sort_cut_off)
         {
             assert(__nsort > 0 && __nsort <= __n);
-            buffer<_ValueType> __buf(__n);
+            buffer<_ValueType> __buf(std::forward<_ExecutionPolicy>(__exec), __n);
             using tbb::task;
             task::spawn_root_and_wait(*new (task::allocate_root())
                                           stable_sort_task<_RandomAccessIterator, _ValueType*, _Compare, _LeafSort>(
Index: include/pstl/internal/parallel_backend_utils.h
===================================================================
--- include/pstl/internal/parallel_backend_utils.h
+++ include/pstl/internal/parallel_backend_utils.h
@@ -128,7 +128,7 @@
 template <typename _Buf>
 class stack
 {
-    typedef typename std::iterator_traits<decltype(_Buf(0).get())>::value_type _ValueType;
+    typedef typename std::iterator_traits<decltype(std::declval<_Buf>().get())>::value_type _ValueType;
     typedef typename std::iterator_traits<_ValueType*>::difference_type _DifferenceType;
 
     _Buf _M_buf;
@@ -140,7 +140,9 @@
     operator=(const stack&) = delete;
 
   public:
-    stack(_DifferenceType __max_size) : _M_buf(__max_size), _M_maxsize(__max_size) { _M_ptr = _M_buf.get(); }
+    template <typename _ExecutionPolicy>
+    stack(_ExecutionPolicy&& __exec, _DifferenceType __max_size)
+        : _M_buf(std::forward<_ExecutionPolicy>(__exec), __max_size), _M_maxsize(__max_size) { _M_ptr = _M_buf.get(); }
 
     ~stack()
     {