Merge branch 'development' into embb9_tarball_script

ffa2f18a · Christian Kern · 938c3be8 · ad71c970 · ffa2f18a · ffa2f18a
Commit ffa2f18a authored Mar 02, 2015 by Christian Kern
48 changed files
--- a/algorithms_cpp/include/embb/algorithms/internal/count-inl.h
+++ b/algorithms_cpp/include/embb/algorithms/internal/count-inl.h
@@ -37,42 +37,45 @@ namespace internal {
 template<typename ValueType>
 class ValueComparisonFunction{
 public:
-  explicit ValueComparisonFunction(const ValueType &value)
+  explicit ValueComparisonFunction(const ValueType& value)
-  :value_(value) {}
+  : value_(value) {}
-  ValueComparisonFunction(const ValueComparisonFunction &other)
+  ValueComparisonFunction(const ValueComparisonFunction& other)
-  :value_(other.value_) {}
+  : value_(other.value_) {}
  template<typename ElementType>
  int operator()(ElementType element) {
-    if(element == value_)
+    if (element == value_) {
      return 1;
-    else
+    } else {
      return 0;
    }
+  }
 private:
  const ValueType &value_;
-  ValueComparisonFunction &operator=(const ValueComparisonFunction &other);
+  ValueComparisonFunction &operator=(
+    const ValueComparisonFunction& other);
 };
 template<typename Function>
 class FunctionComparisonFunction{
 public:
  explicit FunctionComparisonFunction(Function function)
-  :function_(function) {}
+  : function_(function) {}
  FunctionComparisonFunction(const FunctionComparisonFunction &other)
-  :function_(other.function_) {}
+  : function_(other.function_) {}
  template<typename ElementType>
  int operator()(ElementType element) {
-    if(function_(element))
+    if (function_(element)) {
      return 1;
-    else
+    } else {
      return 0;
    }
+  }
 private:
  Function function_;
-  FunctionComparisonFunction &operator=(const FunctionComparisonFunction &
+  FunctionComparisonFunction &operator=(
-      other);
+    const FunctionComparisonFunction& other);
 };
 }  // namespace internal

--- a/algorithms_cpp/include/embb/algorithms/internal/for_each-inl.h
+++ b/algorithms_cpp/include/embb/algorithms/internal/for_each-inl.h
@@ -45,44 +45,54 @@ class ForEachFunctor {
  /**
   * Constructs a for-each functor with arguments.
   */
-  ForEachFunctor(RAI first, RAI last, Function unary,
+  ForEachFunctor(size_t chunk_first, size_t chunk_last, Function unary,
-    const embb::mtapi::ExecutionPolicy& policy, size_t block_size)
+                 const embb::mtapi::ExecutionPolicy& policy,
-    : first_(first), last_(last), unary_(unary), policy_(policy),
+                 const BlockSizePartitioner<RAI>& partitioner)
-      block_size_(block_size) {
+  : chunk_first_(chunk_first), chunk_last_(chunk_last),
+    unary_(unary), policy_(policy), partitioner_(partitioner) {
  }
  void Action(mtapi::TaskContext&) {
-    size_t distance = static_cast<size_t>(std::distance(first_, last_));
+    if (chunk_first_ == chunk_last_) {
-    if (distance == 0) return;
+      // Leaf case, recursed to single chunk. Do work on chunk:
-    if (distance <= block_size_) {  // leaf case -> do work
+      ChunkDescriptor<RAI> chunk = partitioner_[chunk_first_];
-      for (RAI curIter(first_); curIter != last_; ++curIter) {
+      RAI first = chunk.GetFirst();
-        unary_(*curIter);
+      RAI last  = chunk.GetLast();
+      for (RAI it = first; it != last; ++it) {
+        unary_(*it);
      }
-    } else {  // recurse further
+    } else {
-      ChunkPartitioner<RAI> partitioner(first_, last_, 2);
+      // Recurse further:
-      ForEachFunctor<RAI, Function> functorL(partitioner[0].GetFirst(),
+      size_t chunk_split_index = (chunk_first_ + chunk_last_) / 2;
-        partitioner[0].GetLast(), unary_, policy_, block_size_);
+      // Split chunks into left / right branches:
-      ForEachFunctor<RAI, Function> functorR(partitioner[1].GetFirst(),
+      self_t functor_l(chunk_first_,
-        partitioner[1].GetLast(), unary_, policy_, block_size_);
+                       chunk_split_index,
+                       unary_, policy_, partitioner_);
-      mtapi::Node& node = mtapi::Node::GetInstance();
+      self_t functor_r(chunk_split_index + 1,
-      mtapi::Task taskL = node.Spawn(mtapi::Action(base::MakeFunction(
+                       chunk_last_,
-          functorL, &ForEachFunctor<RAI, Function>::Action),
+                       unary_, policy_, partitioner_);
+      mtapi::Task task_l = mtapi::Node::GetInstance().Spawn(
+        mtapi::Action(
+          base::MakeFunction(functor_l, &self_t::Action),
          policy_));
-      mtapi::Task taskR = node.Spawn(mtapi::Action(base::MakeFunction(
+      mtapi::Task task_r = mtapi::Node::GetInstance().Spawn(
-          functorR, &ForEachFunctor<RAI, Function>::Action),
+        mtapi::Action(
+          base::MakeFunction(functor_r, &self_t::Action),
          policy_));
-      taskL.Wait(MTAPI_INFINITE);
+      task_l.Wait(MTAPI_INFINITE);
-      taskR.Wait(MTAPI_INFINITE);
+      task_r.Wait(MTAPI_INFINITE);
    }
  }
 private:
-  RAI first_;
+  typedef ForEachFunctor<RAI, Function> self_t;
-  RAI last_;
+ private:
+  size_t chunk_first_;
+  size_t chunk_last_;
  Function unary_;
  const embb::mtapi::ExecutionPolicy& policy_;
-  size_t block_size_;
+  const BlockSizePartitioner<RAI>& partitioner_;
  /**
   * Disables assignment.
@@ -95,21 +105,33 @@ void ForEachRecursive(RAI first, RAI last, Function unary,
  const embb::mtapi::ExecutionPolicy& policy, size_t block_size) {
  typedef typename std::iterator_traits<RAI>::difference_type difference_type;
  difference_type distance = std::distance(first, last);
-  assert(distance > 0);
+  if (distance == 0) {
+    return;
+  } else if (distance < 0) {
+    EMBB_THROW(embb::base::ErrorException, "Negative range for ForEach");
+  }
+  unsigned int num_cores = policy.GetCoreCount();
+  if (num_cores == 0) {
+    EMBB_THROW(embb::base::ErrorException, "No cores in execution policy");
+  }
  mtapi::Node& node = mtapi::Node::GetInstance();
  // Determine actually used block size
  if (block_size == 0) {
-    block_size = (static_cast<size_t>(distance) / node.GetCoreCount());
+    block_size = (static_cast<size_t>(distance) / num_cores);
    if (block_size == 0) {
      block_size = 1;
    }
  }
-  // Perform check of task number sufficiency
+  // Check task number sufficiency
  if (((distance / block_size) * 2) + 1 > MTAPI_NODE_MAX_TASKS_DEFAULT) {
-    EMBB_THROW(embb::base::ErrorException, "Not enough MTAPI tasks available "
+    EMBB_THROW(embb::base::ErrorException,
-               "to perform the parallel foreach loop");
+               "Not enough MTAPI tasks available for parallel foreach");
  }
-  ForEachFunctor<RAI, Function> functor(first, last, unary, policy, block_size);
+  BlockSizePartitioner<RAI> partitioner(first, last, block_size);
+  ForEachFunctor<RAI, Function> functor(0,
+                                        partitioner.Size() - 1,
+                                        unary, policy, partitioner);
  mtapi::Task task = node.Spawn(mtapi::Action(
                     base::MakeFunction(functor,
                       &ForEachFunctor<RAI, Function>::Action),
@@ -127,7 +149,7 @@ void ForEachIteratorCheck(RAI first, RAI last, Function unary,
 }  // namespace internal
 template<typename RAI, typename Function>
-void ForEach(RAI first, RAI last, Function unary,
+void ForEach(RAI first, const RAI last, Function unary,
  const embb::mtapi::ExecutionPolicy& policy, size_t block_size) {
  typename std::iterator_traits<RAI>::iterator_category category;
  internal::ForEachIteratorCheck(first, last, unary, policy, block_size,

--- a/algorithms_cpp/include/embb/algorithms/internal/merge_sort-inl.h
+++ b/algorithms_cpp/include/embb/algorithms/internal/merge_sort-inl.h
--- a/algorithms_cpp/include/embb/algorithms/internal/partition-inl.h
+++ b/algorithms_cpp/include/embb/algorithms/internal/partition-inl.h
@@ -71,8 +71,8 @@ const ChunkDescriptor<ForwardIterator>
  ForwardIterator last_new = first_new;
-  if (index == elements_count / chunkSize) {
+  if (index >= chunks - 1) {
-    std::advance(last_new, elements_count % chunkSize);
+    last_new = last;
  } else {
    std::advance(last_new, chunkSize);
  }
@@ -94,7 +94,7 @@ ChunkPartitioner<ForwardIterator>::ChunkPartitioner(ForwardIterator first,
  } else {
    // if no concrete chunk size was given, use number of cores...
    mtapi::Node& node = mtapi::Node::GetInstance();
-    size = node.GetCoreCount();
+    size = node.GetWorkerThreadCount();
  }
  elements_count = static_cast<size_t>(std::distance(first, last));

--- a/algorithms_cpp/include/embb/algorithms/internal/quick_sort-inl.h
+++ b/algorithms_cpp/include/embb/algorithms/internal/quick_sort-inl.h
@@ -186,16 +186,26 @@ class QuickSortFunctor {
  QuickSortFunctor(const QuickSortFunctor&);
 };
-}  // namespace internal
 template <typename RAI, typename ComparisonFunction>
-void QuickSort(RAI first, RAI last, ComparisonFunction comparison,
+void QuickSortIteratorCheck(RAI first, RAI last,
-  const embb::mtapi::ExecutionPolicy& policy, size_t block_size) {
+  ComparisonFunction comparison,
+  const embb::mtapi::ExecutionPolicy& policy,
+  size_t block_size,
+  std::random_access_iterator_tag) {
  embb::mtapi::Node& node = embb::mtapi::Node::GetInstance();
-  typename std::iterator_traits<RAI>::difference_type distance = last - first;
+  typedef typename std::iterator_traits<RAI>::difference_type difference_type;
-  assert(distance > 0);
+  difference_type distance = std::distance(first, last);
+  if (distance == 0) {
+    return;
+  } else if (distance < 0) {
+    EMBB_THROW(embb::base::ErrorException, "Negative range for QuickSort");
+  }
+  unsigned int num_cores = policy.GetCoreCount();
+  if (num_cores == 0) {
+    EMBB_THROW(embb::base::ErrorException, "No cores in execution policy");
+  }
  if (block_size == 0) {
-    block_size = (static_cast<size_t>(distance) / node.GetCoreCount());
+    block_size = (static_cast<size_t>(distance) / num_cores);
    if (block_size == 0)
      block_size = 1;
  }
@@ -203,13 +213,23 @@ void QuickSort(RAI first, RAI last, ComparisonFunction comparison,
    EMBB_THROW(embb::base::ErrorException,
               "Not enough MTAPI tasks available for performing quick sort");
  }
-  internal::QuickSortFunctor<RAI, ComparisonFunction> functor(
+  QuickSortFunctor<RAI, ComparisonFunction> functor(
      first, last, comparison, policy, block_size);
  mtapi::Task task = node.Spawn(mtapi::Action(base::MakeFunction(
-      functor, &internal::QuickSortFunctor<RAI, ComparisonFunction>::Action)));
+      functor, &QuickSortFunctor<RAI, ComparisonFunction>::Action)));
  task.Wait(MTAPI_INFINITE);
 }
+}  // namespace internal
+template <typename RAI, typename ComparisonFunction>
+void QuickSort(RAI first, RAI last, ComparisonFunction comparison,
+  const embb::mtapi::ExecutionPolicy& policy, size_t block_size) {
+  typedef typename std::iterator_traits<RAI>::iterator_category category;
+  internal::QuickSortIteratorCheck(first, last, comparison,
+                                   policy, block_size, category());
+}
 }  // namespace algorithms
 }  // namespace embb

--- a/algorithms_cpp/include/embb/algorithms/internal/reduce-inl.h
+++ b/algorithms_cpp/include/embb/algorithms/internal/reduce-inl.h
@@ -42,45 +42,55 @@ template<typename RAI, typename ReturnType, typename ReductionFunction,
         typename TransformationFunction>
 class ReduceFunctor {
 public:
-  ReduceFunctor(RAI first, RAI last, ReturnType neutral,
+  ReduceFunctor(size_t chunk_first, size_t chunk_last,
+                ReturnType neutral,
                ReductionFunction reduction,
                TransformationFunction transformation,
-                const embb::mtapi::ExecutionPolicy &policy, size_t block_size,
+                const embb::mtapi::ExecutionPolicy& policy,
+                const BlockSizePartitioner<RAI>& partitioner,
                ReturnType& result)
-  :
+  : chunk_first_(chunk_first), chunk_last_(chunk_last), neutral_(neutral),
-      first_(first), last_(last), neutral_(neutral), reduction_(reduction),
+    reduction_(reduction), transformation_(transformation), policy_(policy),
-      transformation_(transformation), policy_(policy),
+    partitioner_(partitioner), result_(result) {
-      block_size_(block_size), result_(result) {
  }
  void Action(mtapi::TaskContext&) {
-    if (first_ == last_) {
+    if (chunk_first_ == chunk_last_) {
-      return;
+      // Leaf case, recursed to single chunk. Do work on chunk:
-    }
+      ChunkDescriptor<RAI> chunk = partitioner_[chunk_first_];
-    size_t distance = static_cast<size_t>(std::distance(first_, last_));
+      RAI first = chunk.GetFirst();
-    if (distance <= block_size_) {  // leaf case -> do work
+      RAI last  = chunk.GetLast();
      ReturnType result(neutral_);
-      for (RAI iter = first_; iter != last_; ++iter) {
+      for (RAI it = first; it != last; ++it) {
-        result = reduction_(result, transformation_(*iter));
+        result = reduction_(result, transformation_(*it));
      }
      result_ = result;
-    } else {  // recurse further
+    } else {
-      internal::ChunkPartitioner<RAI> partitioner(first_, last_, 2);
+      // Recurse further:
+      size_t chunk_split_index = (chunk_first_ + chunk_last_) / 2;
+      // Split chunks into left / right branches:
      ReturnType result_l(neutral_);
      ReturnType result_r(neutral_);
-      ReduceFunctor functor_l(partitioner[0].GetFirst(),
+      self_t functor_l(chunk_first_,
-                              partitioner[0].GetLast(),
+                       chunk_split_index,
                       neutral_, reduction_, transformation_, policy_,
-                              block_size_, result_l);
+                       partitioner_,
-      ReduceFunctor functor_r(partitioner[1].GetFirst(),
+                       result_l);
-                              partitioner[1].GetLast(),
+      self_t functor_r(chunk_split_index + 1,
+                       chunk_last_,
                       neutral_, reduction_, transformation_, policy_,
-                              block_size_, result_r);
+                       partitioner_,
-      mtapi::Node& node = mtapi::Node::GetInstance();
+                       result_r);
-      mtapi::Task task_l = node.Spawn(mtapi::Action(base::MakeFunction(
+      mtapi::Task task_l = mtapi::Node::GetInstance().Spawn(
-          functor_l, &ReduceFunctor::Action), policy_));
+        mtapi::Action(
-      mtapi::Task task_r = node.Spawn(mtapi::Action(base::MakeFunction(
+          base::MakeFunction(
-          functor_r, &ReduceFunctor::Action), policy_));
+          functor_l, &self_t::Action),
+          policy_));
+      mtapi::Task task_r = mtapi::Node::GetInstance().Spawn(
+        mtapi::Action(
+          base::MakeFunction(
+          functor_r, &self_t::Action),
+          policy_));
      task_l.Wait(MTAPI_INFINITE);
      task_r.Wait(MTAPI_INFINITE);
      result_ = reduction_(result_l, result_r);
@@ -88,15 +98,23 @@ class ReduceFunctor {
  }
 private:
-  RAI first_;
+  typedef ReduceFunctor<RAI, ReturnType,
-  RAI last_;
+                        ReductionFunction,
+                        TransformationFunction> self_t;
+ private:
+  size_t chunk_first_;
+  size_t chunk_last_;
  ReturnType neutral_;
  ReductionFunction reduction_;
  TransformationFunction transformation_;
  const embb::mtapi::ExecutionPolicy& policy_;
-  size_t block_size_;
+  const BlockSizePartitioner<RAI>& partitioner_;
  ReturnType& result_;
+  /**
+   * Disables assignment and copy-construction.
+   */
  ReduceFunctor& operator=(const ReduceFunctor&);
  ReduceFunctor(const ReduceFunctor&);
 };
@@ -110,27 +128,42 @@ ReturnType ReduceRecursive(RAI first, RAI last, ReturnType neutral,
                           size_t block_size) {
  typedef typename std::iterator_traits<RAI>::difference_type difference_type;
  difference_type distance = std::distance(first, last);
-  assert(distance > 0);
+  if (distance == 0) {
+    return neutral;
+  } else if (distance < 0) {
+    EMBB_THROW(embb::base::ErrorException, "Negative range for Reduce");
+  }
+  unsigned int num_cores = policy.GetCoreCount();
+  if (num_cores == 0) {
+    EMBB_THROW(embb::base::ErrorException, "No cores in execution policy");
+  }
  mtapi::Node& node = mtapi::Node::GetInstance();
-  size_t used_block_size = block_size;
+  // Determine actually used block size
-  if (used_block_size == 0) {
+  if (block_size == 0) {
-      used_block_size = static_cast<size_t>(distance) / node.GetCoreCount();
+    block_size = (static_cast<size_t>(distance) / num_cores);
-      if (used_block_size == 0) used_block_size = 1;
+    if (block_size == 0) {
+      block_size = 1;
    }
+  }
-  if (((distance / used_block_size) * 2) + 1 > MTAPI_NODE_MAX_TASKS_DEFAULT) {
+  // Perform check of task number sufficiency
+  if (((distance / block_size) * 2) + 1 > MTAPI_NODE_MAX_TASKS_DEFAULT) {
    EMBB_THROW(embb::base::ErrorException,
               "Number of computation tasks required in reduction would "
               "exceed MTAPI maximum number of tasks");
  }
-  ReturnType result = neutral;
  typedef ReduceFunctor<RAI, ReturnType, ReductionFunction,
                        TransformationFunction> Functor;
-  Functor functor(first, last, neutral, reduction, transformation, policy,
+  BlockSizePartitioner<RAI> partitioner(first, last, block_size);
-                  used_block_size, result);
+  ReturnType result = neutral;
-  mtapi::Task task = node.Spawn(mtapi::Action(base::MakeFunction(
+  Functor functor(0,
+                  partitioner.Size() - 1,
+                  neutral,
+                  reduction, transformation,
+                  policy,
+                  partitioner,
+                  result);
+  mtapi::Task task = node.Spawn(
+    mtapi::Action(base::MakeFunction(
      functor, &Functor::Action), policy));
  task.Wait(MTAPI_INFINITE);
  return result;

--- a/algorithms_cpp/include/embb/algorithms/internal/scan-inl.h
+++ b/algorithms_cpp/include/embb/algorithms/internal/scan-inl.h
@@ -41,73 +41,79 @@ template<typename RAIIn, typename RAIOut, typename ReturnType,
 typename ScanFunction, typename TransformationFunction>
 class ScanFunctor {
 public:
-  ScanFunctor(RAIIn first, RAIIn last, RAIOut output_iterator,
+  ScanFunctor(size_t chunk_first, size_t chunk_last, RAIOut output_iterator,
              ReturnType neutral, ScanFunction scan,
              TransformationFunction transformation,
              const embb::mtapi::ExecutionPolicy& policy,
-              size_t block_size, ReturnType* tree_values, size_t node_id,
+              const BlockSizePartitioner<RAIIn>& partitioner,
+              ReturnType* tree_values, size_t node_id,
              bool going_down)
-    : policy_(policy), first_(first), last_(last),
+    : policy_(policy), chunk_first_(chunk_first), chunk_last_(chunk_last),
      output_iterator_(output_iterator), scan_(scan),
      transformation_(transformation),
-      neutral_(neutral), block_size_(block_size), tree_values_(tree_values),
+      neutral_(neutral), partitioner_(partitioner), tree_values_(tree_values),
      node_id_(node_id), parent_value_(neutral), is_first_pass_(going_down)  {
  }
  void Action(mtapi::TaskContext&) {
-    if (first_ == last_) {
+    if (chunk_first_ == chunk_last_) {
-      return;
+      ChunkDescriptor<RAIIn> chunk = partitioner_[chunk_first_];
-    }
+      RAIIn iter_in = chunk.GetFirst();
-    size_t distance = static_cast<size_t>(std::distance(first_, last_));
+      RAIIn last_in = chunk.GetLast();
-    if (distance <= block_size_) {  // leaf case -> do work
-      if (is_first_pass_) {
-        RAIIn iter_in = first_;
      RAIOut iter_out = output_iterator_;
-        ReturnType result = transformation_(*first_);
+      // leaf case -> do work
+      if (is_first_pass_) {
+        ReturnType result = transformation_(*iter_in);
        *iter_out = result;
        ++iter_in;
        ++iter_out;
-        while (iter_in != last_) {
+        for (; iter_in != last_in; ++iter_in, ++iter_out) {
          result = scan_(result, transformation_(*iter_in));
          *iter_out = result;
-          ++iter_in;
-          ++iter_out;
        }
        SetTreeValue(result);
-      } else { // Second pass
+      } else {
-        RAIIn iter_in = first_;
+        // Second pass
-        RAIOut iter_out = output_iterator_;
+        for (; iter_in != last_in; ++iter_in, ++iter_out) {
-        while (iter_in != last_) {
          *iter_out = scan_(parent_value_, *iter_out);
-          ++iter_in;
-          ++iter_out;
        }
      }
    } else {
-      internal::ChunkPartitioner<RAIIn> partitioner(first_, last_, 2);
+      // recurse further
-      ScanFunctor functor_l(partitioner[0].GetFirst(), partitioner[0].GetLast(),
+      size_t chunk_split_index = (chunk_first_ + chunk_last_) / 2;
+      // Split chunks into left / right branches:
+      ScanFunctor functor_l(
+        chunk_first_, chunk_split_index,
        output_iterator_, neutral_, scan_, transformation_,
-                            policy_, block_size_, tree_values_, node_id_,
+        policy_, partitioner_, tree_values_, node_id_,
        is_first_pass_);
-      ScanFunctor functor_r(partitioner[1].GetFirst(), partitioner[1].GetLast(),
+      ScanFunctor functor_r(
+        chunk_split_index + 1, chunk_last_,
        output_iterator_, neutral_, scan_, transformation_,
-                            policy_, block_size_, tree_values_, node_id_,
+        policy_, partitioner_, tree_values_, node_id_,
        is_first_pass_);
-      functor_l.SetID(1);
+      functor_l.SetID(LEFT);
-      functor_r.SetID(2);
+      functor_r.SetID(RIGHT);
+      // Advance output iterator of right branch:
+      ChunkDescriptor<RAIIn> chunk_left  = partitioner_[chunk_first_];
+      ChunkDescriptor<RAIIn> chunk_right = partitioner_[chunk_split_index + 1];
      std::advance(functor_r.output_iterator_,
-                   std::distance(functor_l.first_, functor_r.first_));
+          std::distance(chunk_left.GetFirst(), chunk_right.GetFirst()));
      if (!is_first_pass_) {
        functor_l.parent_value_ = parent_value_;
        functor_r.parent_value_ = functor_l.GetTreeValue() + parent_value_;
      }
+      // Spawn tasks to recurse:
      mtapi::Node& node = mtapi::Node::GetInstance();
-      mtapi::Task task_l = node.Spawn(mtapi::Action(base::MakeFunction(
+      mtapi::Task task_l = node.Spawn(
-                                      functor_l, &ScanFunctor::Action),
+        mtapi::Action(
+          base::MakeFunction(functor_l, &ScanFunctor::Action),
          policy_));
-       mtapi::Task task_r = node.Spawn(mtapi::Action(base::MakeFunction(
+      mtapi::Task task_r = node.Spawn(
-                                       functor_r, &ScanFunctor::Action),
+        mtapi::Action(
+          base::MakeFunction(functor_r, &ScanFunctor::Action),
          policy_));
+      // Wait for tasks to complete:
      task_l.Wait(MTAPI_INFINITE);
      task_r.Wait(MTAPI_INFINITE);
      SetTreeValue(scan_(functor_l.GetTreeValue(), functor_r.GetTreeValue()));
@@ -123,23 +129,25 @@ class ScanFunctor {
  }
 private:
+  static const int LEFT  = 1;
+  static const int RIGHT = 2;
  const embb::mtapi::ExecutionPolicy& policy_;
-  RAIIn first_;
+  size_t chunk_first_;
-  RAIIn last_;
+  size_t chunk_last_;
  RAIOut output_iterator_;
  ScanFunction scan_;
  TransformationFunction transformation_;
  ReturnType neutral_;
-  size_t block_size_;
+  const BlockSizePartitioner<RAIIn>& partitioner_;
  ReturnType* tree_values_;
  size_t node_id_;
  ReturnType parent_value_;
  bool is_first_pass_;
-  void SetID(int is_left) {
+  void SetID(int branch) {
-    if (is_left == 1) {
+    if (branch == LEFT) {
      node_id_ = 2 * node_id_ + 1;
-    } else if (is_left == 2) {
+    } else if (branch == RIGHT) {
      node_id_ = 2 * node_id_ + 2;
    }
  }
@@ -165,37 +173,48 @@ void ScanIteratorCheck(RAIIn first, RAIIn last, RAIOut output_iterator,
                       std::random_access_iterator_tag) {
  typedef typename std::iterator_traits<RAIIn>::difference_type difference_type;
  difference_type distance = std::distance(first, last);
-  if (distance <= 0) {
+  if (distance == 0) {
    return;
+  } else if (distance < 0) {
+    EMBB_THROW(embb::base::ErrorException, "Negative range for Scan");
  }
-  mtapi::Node& node = mtapi::Node::GetInstance();
+  unsigned int num_cores = policy.GetCoreCount();
+  if (num_cores == 0) {
+    EMBB_THROW(embb::base::ErrorException, "No cores in execution policy");
+  }
  ReturnType values[MTAPI_NODE_MAX_TASKS_DEFAULT];
-  size_t used_block_size = block_size;
  if (block_size == 0) {
-    used_block_size = static_cast<size_t>(distance) / node.GetCoreCount();
+    block_size = static_cast<size_t>(distance) / num_cores;
-    if (used_block_size == 0) used_block_size = 1;
+    if (block_size == 0) {
+      block_size = 1;
+    }
  }
-  if (((distance / used_block_size) * 2) + 1 > MTAPI_NODE_MAX_TASKS_DEFAULT) {
+  if (((distance / block_size) * 2) + 1 > MTAPI_NODE_MAX_TASKS_DEFAULT) {
    EMBB_THROW(embb::base::ErrorException,
-               "Number of computation tasks required in scan "
+               "Not enough MTAPI tasks available for parallel scan");
-               "exceeds MTAPI maximum number of tasks");
  }
  // first pass. Calculates prefix sums for leaves and when recursion returns
  // it creates the tree.
  typedef ScanFunctor<RAIIn, RAIOut, ReturnType, ScanFunction,
                      TransformationFunction> Functor;
-  Functor functor_down(first, last, output_iterator, neutral, scan,
+  mtapi::Node& node = mtapi::Node::GetInstance();
-                       transformation, policy, used_block_size, values, 0,
-                       true);
+  BlockSizePartitioner<RAIIn> partitioner_down(first, last, block_size);
+  Functor functor_down(0, partitioner_down.Size() - 1, output_iterator,
+                       neutral, scan, transformation, policy, partitioner_down,
+                       values, 0, true);
  mtapi::Task task_down = node.Spawn(mtapi::Action(base::MakeFunction(
                          functor_down, &Functor::Action),
                          policy));
  task_down.Wait(MTAPI_INFINITE);
  // Second pass. Gives to each leaf the part of the prefix missing
-  Functor functor_up(first, last, output_iterator, neutral, scan,
+  BlockSizePartitioner<RAIIn> partitioner_up(first, last, block_size);
-                     transformation, policy, used_block_size, values, 0, false);
+  Functor functor_up(0, partitioner_up.Size() - 1, output_iterator,
+                     neutral, scan, transformation, policy, partitioner_up,
+                     values, 0, false);
  mtapi::Task task_up = node.Spawn(mtapi::Action(base::MakeFunction(
                        functor_up, &Functor::Action),
                        policy));

--- a/algorithms_cpp/include/embb/algorithms/invoke.h
+++ b/algorithms_cpp/include/embb/algorithms/invoke.h
@@ -58,7 +58,7 @@ typedef embb::base::Function<void> InvokeFunctionType;
 template<typename Function1, ...>
 void Invoke(
  Function1 func1,
-  /**< [in] First function to invoke */
+  /**< [in] First function object to invoke */
  ...);
 /**
@@ -72,7 +72,7 @@ void Invoke(
 template<typename Function1, ...>
 void Invoke(
  Function1 func1,
-  /**< [in] Function to invoke */
+  /**< [in] Function object to invoke */
  ...,
  const embb::mtapi::ExecutionPolicy & policy
  /**< [in] embb::mtapi::ExecutionPolicy to use */

--- a/algorithms_cpp/include/embb/algorithms/merge_sort.h
+++ b/algorithms_cpp/include/embb/algorithms/merge_sort.h
@@ -167,9 +167,20 @@ void MergeSortAllocate(
  typedef base::Allocation Alloc;
  typename std::iterator_traits<RAI>::difference_type distance = last - first;
  typedef typename std::iterator_traits<RAI>::value_type value_type;
+  if (distance == 0) {
+    return;
+  } else if (distance < 0) {
+    EMBB_THROW(embb::base::ErrorException, "Negative range for MergeSort");
+  }
  value_type* temporary = static_cast<value_type*>(
                            Alloc::Allocate(distance * sizeof(value_type)));
+  EMBB_TRY {
    MergeSort(first, last, temporary, comparison, policy, block_size);
+  } EMBB_CATCH (embb::base::ErrorException & e) {
+    // embb exception handling does not support catch(...) and rethrow yet.
+    Alloc::Free(temporary);
+    EMBB_THROW(embb::base::ErrorException, e.what());
+  }
  Alloc::Free(temporary);
 }

--- a/algorithms_cpp/include/embb/algorithms/reduce.h
+++ b/algorithms_cpp/include/embb/algorithms/reduce.h
@@ -68,10 +68,10 @@ namespace algorithms {
 * \tparam RAI Random access iterator
 * \tparam ReturnType Type of result of reduction operation, deduced from
 *         \c neutral
- * \tparam ReductionFunction Binary reduction function with signature
+ * \tparam ReductionFunction Binary reduction function object with signature
 *         <tt>ReturnType ReductionFunction(ReturnType, ReturnType)</tt>.
- * \tparam TransformationFunction Unary transformation function with signature
+ * \tparam TransformationFunction Unary transformation function object with
- *         <tt>ReturnType TransformationFunction(typename
+ *         signature <tt>ReturnType TransformationFunction(typename
 *         std::iterator_traits<RAI>::value_type)</tt>
 */
 template<typename RAI, typename ReturnType, typename ReductionFunction,

--- a/algorithms_cpp/include/embb/algorithms/scan.h
+++ b/algorithms_cpp/include/embb/algorithms/scan.h
@@ -71,10 +71,10 @@ namespace algorithms {
 * \tparam RAIOut Random access iterator type of output range
 * \tparam ReturnType Type of output elements of scan operation, deduced from
 *         \c neutral
- * \tparam ScanFunction Binary scan function with signature
+ * \tparam ScanFunction Binary scan function object with signature
 *         <tt>ReturnType ScanFunction(ReturnType, ReturnType)</tt>
- * \tparam TransformationFunction Unary transformation function with signature
+ * \tparam TransformationFunction Unary transformation function object with
- *         <tt>ReturnType TransformationFunction(typename
+ *         signature <tt>ReturnType TransformationFunction(typename
 *         std::iterator_traits<RAIIn>::value_type)</tt>.
 */
 template<typename RAIIn, typename RAIOut, typename ReturnType,

--- a/algorithms_cpp/test/count_test.cc
+++ b/algorithms_cpp/test/count_test.cc
@@ -60,7 +60,7 @@ CountTest::CountTest() {
 void CountTest::TestDataStructures() {
  using embb::algorithms::Count;
  const int size = 10;
-  int array[] = {10, 20, 30, 30, 20, 10, 10, 20, 20, 20};
+  int array[] = { 10, 20, 30, 30, 20, 10, 10, 20, 20, 20 };
  std::vector<int> vector(array, array + size);
  std::deque<int> deque(array, array + size);
  const std::vector<int> const_vector(array, array + size);
@@ -74,7 +74,7 @@ void CountTest::TestDataStructures() {
 void CountTest::TestCountIf() {
  using embb::algorithms::CountIf;
  const int size = 10;
-  int array[] = {10, 21, 30, 31, 20, 11, 10, 21, 20, 20};
+  int array[] = { 10, 21, 30, 31, 20, 11, 10, 21, 20, 20 };
  PT_EXPECT_EQ(CountIf(array, array + size, IsEven()), 6);
  PT_EXPECT_EQ(CountIf(array, array + size, &IsEvenFunction), 6);
 }
@@ -128,8 +128,6 @@ void CountTest::TestPolicy() {
  PT_EXPECT_EQ(Count(vector.begin(), vector.end(), 10, ExecutionPolicy()), 3);
  PT_EXPECT_EQ(Count(vector.begin(), vector.end(), 10, ExecutionPolicy(true)),
               3);
-  PT_EXPECT_EQ(Count(vector.begin(), vector.end(), 10, ExecutionPolicy(false)),
-               3);
  PT_EXPECT_EQ(Count(vector.begin(), vector.end(), 10,
               ExecutionPolicy(true, 1)), 3);
 }

--- a/algorithms_cpp/test/for_each_test.cc
+++ b/algorithms_cpp/test/for_each_test.cc
@@ -207,16 +207,35 @@ void ForEachTest::TestPolicy() {
  }
  vector = init;
-  ForEach(vector.begin(), vector.end(), Square(), ExecutionPolicy(false));
+  ForEach(vector.begin(), vector.end(), Square(), ExecutionPolicy(true, 1));
  for (size_t i = 0; i < count; i++) {
    PT_EXPECT_EQ(vector[i], init[i]*init[i]);
  }
-  vector = init;
+  // ForEach on empty list should not throw:
-  ForEach(vector.begin(), vector.end(), Square(), ExecutionPolicy(true, 1));
+  ForEach(vector.begin(), vector.begin(), Square());
-  for (size_t i = 0; i < count; i++) {
-    PT_EXPECT_EQ(vector[i], init[i]*init[i]);
+#ifdef EMBB_USE_EXCEPTIONS
+  bool empty_core_set_thrown = false;
+  try {
+    ForEach(vector.begin(), vector.end(), Square(), ExecutionPolicy(false));
+  }
+  catch (embb::base::ErrorException &) {
+    empty_core_set_thrown = true;
+  }
+  PT_EXPECT_MSG(empty_core_set_thrown,
+    "Empty core set should throw ErrorException");
+  bool negative_range_thrown = false;
+  try {
+    std::vector<int>::iterator second = vector.begin() + 1;
+    ForEach(second, vector.begin(), Square());
+  }
+  catch (embb::base::ErrorException &) {
+    negative_range_thrown = true;
  }
+  PT_EXPECT_MSG(negative_range_thrown,
+    "Negative range should throw ErrorException");
+#endif
 }
 void ForEachTest::StressTest() {

--- a/algorithms_cpp/test/merge_sort_test.cc
+++ b/algorithms_cpp/test/merge_sort_test.cc
@@ -156,28 +156,28 @@ void MergeSortTest::TestRanges() {
  }
 }
-//void MergeSortTest::TestBlockSizes() {
+void MergeSortTest::TestBlockSizes() {
-//  using embb::algorithms::MergeSortAllocate;
+  using embb::algorithms::MergeSortAllocate;
-//  using embb::algorithms::ExecutionPolicy;
+  using embb::mtapi::ExecutionPolicy;
-//  size_t count = 4;
+  size_t count = 4;
-//  std::vector<int> init(count);
+  std::vector<int> init(count);
-//  std::vector<int> vector(count);
+  std::vector<int> vector(count);
-//  std::vector<int> vector_copy(count);
+  std::vector<int> vector_copy(count);
-//  for (size_t i = count - 1; i > 0; i--) {
+  for (size_t i = count - 1; i > 0; i--) {
-//    init[i] = static_cast<int>(i+2);
+    init[i] = static_cast<int>(i+2);
-//  }
+  }
-//  vector_copy = init;
+  vector_copy = init;
-//  std::sort(vector_copy.begin(), vector_copy.end());
+  std::sort(vector_copy.begin(), vector_copy.end());
-//
-//  for (size_t block_size = 1; block_size < count + 2; block_size++) {
+  for (size_t block_size = 1; block_size < count + 2; block_size++) {
-//    vector = init;
+    vector = init;
-//    MergeSortAllocate(vector.begin(), vector.end(), std::less<int>(),
+    MergeSortAllocate(vector.begin(), vector.end(), std::less<int>(),
-//      ExecutionPolicy(), block_size);
+      ExecutionPolicy(), block_size);
-//    for (size_t i = 0; i < count; i++) {
+    for (size_t i = 0; i < count; i++) {
-//      PT_EXPECT_EQ(vector[i], vector_copy[i]);
+      PT_EXPECT_EQ(vector[i], vector_copy[i]);
-//    }
+    }
-//  }
+  }
-//}
+}
 void MergeSortTest::TestPolicy() {
  using embb::algorithms::MergeSortAllocate;
@@ -208,17 +208,36 @@ void MergeSortTest::TestPolicy() {
  vector = init;
  MergeSortAllocate(vector.begin(), vector.end(), std::less<int>(),
-            ExecutionPolicy(false));
+                    ExecutionPolicy(true, 1));
  for (size_t i = 0; i < count; i++) {
     PT_EXPECT_EQ(vector_copy[i], vector[i]);
  }
-  vector = init;
+  // MergeSort on empty list should not throw:
+  MergeSortAllocate(vector.begin(), vector.begin(), std::less<int>());
+#ifdef EMBB_USE_EXCEPTIONS
+  bool empty_core_set_thrown = false;
+  try {
    MergeSortAllocate(vector.begin(), vector.end(), std::less<int>(),
-            ExecutionPolicy(true, 1));
+                      ExecutionPolicy(false));
-  for (size_t i = 0; i < count; i++) {
+  }
-     PT_EXPECT_EQ(vector_copy[i], vector[i]);
+  catch (embb::base::ErrorException &) {
+    empty_core_set_thrown = true;
+  }
+  PT_EXPECT_MSG(empty_core_set_thrown,
+    "Empty core set should throw ErrorException");
+  bool negative_range_thrown = false;
+  try {
+    std::vector<int>::iterator second = vector.begin() + 1;
+    MergeSortAllocate(second, vector.begin(), std::less<int>());
+  }
+  catch (embb::base::ErrorException &) {
+    negative_range_thrown = true;
  }
+  PT_EXPECT_MSG(negative_range_thrown,
+    "Negative range should throw ErrorException");
+#endif
 }
 void MergeSortTest::StressTest() {

--- a/algorithms_cpp/test/merge_sort_test.h
+++ b/algorithms_cpp/test/merge_sort_test.h
@@ -58,7 +58,7 @@ class MergeSortTest : public partest::TestCase {
  /**
   * Tests various block sizes for the workers.
   */
-  //void TestBlockSizes();
+  void TestBlockSizes();
  /**
   * Tests setting policies (without checking their actual execution).

--- a/algorithms_cpp/test/quick_sort_test.cc
+++ b/algorithms_cpp/test/quick_sort_test.cc
@@ -214,17 +214,36 @@ void QuickSortTest::TestPolicy() {
  vector = init;
  QuickSort(vector.begin(), vector.end(), std::greater<int>(),
-            ExecutionPolicy(false));
+            ExecutionPolicy(true, 1));
  for (size_t i = 0; i < count; i++) {
     PT_EXPECT_EQ(vector_copy[i], vector[i]);
  }
-  vector = init;
+  // MergeSort on empty list should not throw:
-  QuickSort(vector.begin(), vector.end(), std::greater<int>(),
+  QuickSort(vector.begin(), vector.begin(), std::less<int>());
-            ExecutionPolicy(true, 1));
-  for (size_t i = 0; i < count; i++) {
+#ifdef EMBB_USE_EXCEPTIONS
-     PT_EXPECT_EQ(vector_copy[i], vector[i]);
+  bool empty_core_set_thrown = false;
+  try {
+    QuickSort(vector.begin(), vector.end(), std::less<int>(),
+      ExecutionPolicy(false));
+  }
+  catch (embb::base::ErrorException &) {
+    empty_core_set_thrown = true;
+  }
+  PT_EXPECT_MSG(empty_core_set_thrown,
+    "Empty core set should throw ErrorException");
+  bool negative_range_thrown = false;
+  try {
+    std::vector<int>::iterator second = vector.begin() + 1;
+    QuickSort(second, vector.begin(), std::less<int>());
+  }
+  catch (embb::base::ErrorException &) {
+    negative_range_thrown = true;
  }
+  PT_EXPECT_MSG(negative_range_thrown,
+    "Negative range should throw ErrorException");
+#endif
 }
 void QuickSortTest::StressTest() {

--- a/algorithms_cpp/test/reduce_test.cc
+++ b/algorithms_cpp/test/reduce_test.cc
@@ -179,10 +179,33 @@ void ReduceTest::TestPolicy() {
               Identity(), ExecutionPolicy()), sum);
  PT_EXPECT_EQ(Reduce(vector.begin(), vector.end(), 0, std::plus<int>(),
               Identity(), ExecutionPolicy(true)), sum);
-  PT_EXPECT_EQ(Reduce(vector.begin(), vector.end(), 0,
-               std::plus<int>(), Identity(), ExecutionPolicy(false)), sum);
  PT_EXPECT_EQ(Reduce(vector.begin(), vector.end(), 0, std::plus<int>(),
               Identity(), ExecutionPolicy(true, 1)), sum);
+  // Empty list should return neutral element:
+  PT_EXPECT_EQ(Reduce(vector.begin(), vector.begin(), 41, std::plus<int>(),
+               Identity(), ExecutionPolicy(true, 1)), 41);
+#ifdef EMBB_USE_EXCEPTIONS
+  bool empty_core_set_thrown = false;
+  try {
+    Reduce(vector.begin(), vector.end(), 0,
+           std::plus<int>(), Identity(),
+           ExecutionPolicy(false));
+  } catch (embb::base::ErrorException &) {
+    empty_core_set_thrown = true;
+  }
+  PT_EXPECT_MSG(empty_core_set_thrown,
+    "Empty core set should throw ErrorException");
+  bool negative_range_thrown = false;
+  try {
+    std::vector<int>::iterator second = vector.begin() + 1;
+    Reduce(second, vector.begin(), 0, std::plus<int>());
+  }
+  catch (embb::base::ErrorException &) {
+    negative_range_thrown = true;
+  }
+  PT_EXPECT_MSG(negative_range_thrown,
+    "Negative range should throw ErrorException");
+#endif
 }
 void ReduceTest::StressTest() {

--- a/algorithms_cpp/test/scan_test.cc
+++ b/algorithms_cpp/test/scan_test.cc
@@ -284,21 +284,41 @@ void ScanTest::TestPolicy() {
  outputVector = init;
  Scan(vector.begin(), vector.end(), outputVector.begin(), 0, std::plus<int>(),
-       Identity(), ExecutionPolicy(false));
+    Identity(), ExecutionPolicy(true, 1));
  expected = 0;
  for (size_t i = 0; i < count; i++) {
    expected += vector[i];
    PT_EXPECT_EQ(expected, outputVector[i]);
  }
+  // Empty list should not throw and not change output:
  outputVector = init;
-  Scan(vector.begin(), vector.end(), outputVector.begin(), 0, std::plus<int>(),
+  std::vector<int>::iterator out_it = outputVector.begin();
-    Identity(), ExecutionPolicy(true, 1));
+  Scan(vector.begin(), vector.begin(), out_it, 0, std::plus<int>());
-  expected = 0;
+  PT_EXPECT(out_it == outputVector.begin());
-  for (size_t i = 0; i < count; i++) {
-    expected += vector[i];
+#ifdef EMBB_USE_EXCEPTIONS
-    PT_EXPECT_EQ(expected, outputVector[i]);
+  bool empty_core_set_thrown = false;
+  try {
+    Scan(vector.begin(), vector.end(), outputVector.begin(),
+         0, std::plus<int>(), Identity(),
+         ExecutionPolicy(false));
+  }
+  catch (embb::base::ErrorException &) {
+    empty_core_set_thrown = true;
+  }
+  PT_EXPECT_MSG(empty_core_set_thrown,
+    "Empty core set should throw ErrorException");
+  bool negative_range_thrown = false;
+  try {
+    std::vector<int>::iterator second = vector.begin() + 1;
+    Scan(second, vector.begin(), outputVector.begin(), 0, std::plus<int>());
+  }
+  catch (embb::base::ErrorException &) {
+    negative_range_thrown = true;
  }
+  PT_EXPECT_MSG(negative_range_thrown,
+    "Negative range should throw ErrorException");
+#endif
 }
 void ScanTest::StressTest() {

--- a/base_c/include/embb/base/c/internal/platform.h
+++ b/base_c/include/embb/base/c/internal/platform.h
--- a/base_c/test/alloc_test.h
+++ b/base_c/test/alloc_test.h
--- a/base_c/test/condition_var_test.h
+++ b/base_c/test/condition_var_test.h
--- a/base_c/test/core_set_test.h
+++ b/base_c/test/core_set_test.h
--- a/base_c/test/counter_test.h
+++ b/base_c/test/counter_test.h
--- a/base_c/test/duration_test.h
+++ b/base_c/test/duration_test.h
--- a/base_c/test/thread_index_test.h
+++ b/base_c/test/thread_index_test.h
--- a/base_c/test/thread_specific_storage_test.h
+++ b/base_c/test/thread_specific_storage_test.h
--- a/base_c/test/thread_test.h
+++ b/base_c/test/thread_test.h
--- a/base_c/test/time_test.h
+++ b/base_c/test/time_test.h
--- a/base_cpp/include/embb/base/core_set.h
+++ b/base_cpp/include/embb/base/core_set.h
--- a/base_cpp/include/embb/base/duration.h
+++ b/base_cpp/include/embb/base/duration.h
--- a/base_cpp/include/embb/base/exceptions.h
+++ b/base_cpp/include/embb/base/exceptions.h
@@ -175,16 +175,6 @@ class Exception : public std::exception {
  }
  /**
-   * Returns the error message.
-   * This is here for compatibility with std::exception.
-   *
-   * \return Pointer to error message
-   */
-  virtual const char* what() const throw() {
-    return What();
-  }
-  /**
   * Returns an integer code representing the exception.
   *
   * \return %Exception code

--- a/base_cpp/include/embb/base/internal/duration-inl.h
+++ b/base_cpp/include/embb/base/internal/duration-inl.h
--- a/base_cpp/include/embb/base/internal/mutex-inl.h
+++ b/base_cpp/include/embb/base/internal/mutex-inl.h
--- a/base_cpp/include/embb/base/internal/thread-inl.h
+++ b/base_cpp/include/embb/base/internal/thread-inl.h
--- a/base_cpp/include/embb/base/internal/thread_closures.h
+++ b/base_cpp/include/embb/base/internal/thread_closures.h
@@ -36,8 +36,8 @@ namespace internal {
 /**
 * Thread closure for thread start function with no arguments.
 *
- * Provides a thread start function calling a callable entity such as a function
+ * Provides a thread start function from which a priorly stored function object 
- * pointer or functor.
+ * is called.
 */
 template<typename Function>
 struct ThreadClosure {
@@ -56,8 +56,8 @@ struct ThreadClosure {
 /**
 * Thread closure for thread start function with one argument.
 *
- * Provides a thread start function calling a callable entity such as a function
+ * Provides a thread start function from which a priorly stored function object
- * pointer or functor.
+ * is called.
 */
 template<typename Function, typename Arg1>
 struct ThreadClosureArg1 {
@@ -78,8 +78,8 @@ struct ThreadClosureArg1 {
 /**
 * Thread closure for thread start function with two arguments.
 *
- * Provides a thread start function calling a callable entity such as a function
+ * Provides a thread start function from which a priorly stored function object
- * pointer or functor.
+ * is called.
 */
 template<typename Function, typename Arg1, typename Arg2>
 struct ThreadClosureArg2 {

--- a/base_cpp/include/embb/base/internal/thread_specific_storage-inl.h
+++ b/base_cpp/include/embb/base/internal/thread_specific_storage-inl.h
--- a/base_cpp/include/embb/base/thread.h
+++ b/base_cpp/include/embb/base/thread.h
@@ -154,12 +154,12 @@ class Thread {
   * \memory A small constant amount of memory to store the function. This
   *         memory is freed the thread is joined.
   * \notthreadsafe
-   * \tparam Function Type of callable
+   * \tparam Function Function object type
   */
  template<typename Function>
  explicit Thread(
    Function function
-    /**< [IN] Callable (without arguments, must be copyable) */
+    /**< [IN] Copyable function object, callable without arguments */
    );
  /**
@@ -174,14 +174,14 @@ class Thread {
   * \memory A small constant amount of memory to store the function. This
   *         memory is freed the thread is joined.
   * \notthreadsafe
-   * \tparam Function Type of callable
+   * \tparam Function Function object type
   */
  template<typename Function>
  explicit Thread(
    CoreSet& core_set,
    /**< [IN] Set of cores on which the thread shall be executed. */
    Function function
-    /**< [IN] Callable (without arguments, must be copyable) */
+    /**< [IN] Copyable function object, callable without arguments */
    );
  /**
@@ -196,13 +196,13 @@ class Thread {
   * \memory A small constant amount of memory to store the function. This
   *         memory is freed the thread is joined.
   * \notthreadsafe
-   * \tparam Function Type of callable
+   * \tparam Function Function object type
   * \tparam Argument Type of argument
   */
  template<typename Function, typename Arg>
  Thread(
    Function function,
-    /**< [IN] Callable (with one argument, must be copyable) */
+    /**< [IN] Copyable function object, callable with one argument */
    Arg arg
    /**< [IN] Argument for function (must be copyable) */
    );
@@ -219,14 +219,14 @@ class Thread {
   * \memory A small constant amount of memory to store the function. This
   *         memory is freed the thread is joined.
   * \notthreadsafe
-   * \tparam Function Type of callable
+   * \tparam Function Function object type
   * \tparam Arg1 Type of first argument
   * \tparam Arg2 Type of second argument
   */
  template<typename Function, typename Arg1, typename Arg2>
  Thread(
    Function function,
-    /**< [IN] Callable (with two arguments, must be copyable) */
+    /**< [IN] Copyable function object, callable with two arguments */
    Arg1 arg1,
    /**< [IN] First argument for function (must be copyable) */
    Arg2 arg2

--- a/base_cpp/include/embb/base/thread_specific_storage.h
+++ b/base_cpp/include/embb/base/thread_specific_storage.h
@@ -35,12 +35,10 @@ namespace embb {
 namespace base {
 namespace test {
 /**
 * Forward declaration for friending.
 */
 class ThreadSpecificStorageTest;
 }
 /**

--- a/base_cpp/include/embb/base/time.h
+++ b/base_cpp/include/embb/base/time.h
--- a/base_cpp/test/thread_test.h
+++ b/base_cpp/test/thread_test.h
@@ -43,8 +43,7 @@ class ThreadTest : public partest::TestCase {
  /**
   * Adds test methods.
   */
-  ThreadTest(); /**<
+  ThreadTest();
-      number of threads concurrently running test methods */
 private:
  /**

--- a/dataflow_cpp/include/embb/dataflow/internal/inputs.h
+++ b/dataflow_cpp/include/embb/dataflow/internal/inputs.h
@@ -89,7 +89,7 @@ class Inputs<Slices, T1, embb::base::internal::Nil, embb::base::internal::Nil,
    const int idx = clock % Slices;
    if (count_[idx] == 0) {
      EMBB_THROW(embb::base::ErrorException,
-        "All inputs already fired for this clock.")
+        "All inputs already fired for this clock.");
    }
    if (--count_[idx] == 0) {
      count_[idx] = 1;
@@ -135,7 +135,7 @@ class Inputs<Slices, T1, T2, embb::base::internal::Nil,
    const int idx = clock % Slices;
    if (count_[idx] == 0) {
      EMBB_THROW(embb::base::ErrorException,
-        "All inputs already fired for this clock.")
+        "All inputs already fired for this clock.");
    }
    if (--count_[idx] == 0) {
      count_[idx] = 2;
@@ -185,7 +185,7 @@ class Inputs<Slices, T1, T2, T3, embb::base::internal::Nil,
    const int idx = clock % Slices;
    if (count_[idx] == 0) {
      EMBB_THROW(embb::base::ErrorException,
-        "All inputs already fired for this clock.")
+        "All inputs already fired for this clock.");
    }
    if (--count_[idx] == 0) {
      count_[idx] = 3;
@@ -238,7 +238,7 @@ class Inputs<Slices, T1, T2, T3, T4, embb::base::internal::Nil>
    const int idx = clock % Slices;
    if (count_[idx] == 0) {
      EMBB_THROW(embb::base::ErrorException,
-        "All inputs already fired for this clock.")
+        "All inputs already fired for this clock.");
    }
    if (--count_[idx] == 0) {
      count_[idx] = 4;
@@ -296,7 +296,7 @@ class Inputs
    const int idx = clock % Slices;
    if (count_[idx] == 0) {
      EMBB_THROW(embb::base::ErrorException,
-        "All inputs already fired for this clock.")
+        "All inputs already fired for this clock.");
    }
    if (--count_[idx] == 0) {
      count_[idx] = 5;

--- a/mtapi_c/include/embb/mtapi/c/mtapi.h
+++ b/mtapi_c/include/embb/mtapi/c/mtapi.h
@@ -68,7 +68,7 @@
 *   </tr>
 *   <tr>
 *     <td>Action Function</td>
- *     <td>The callable, an executable function of an action, invoked by the
+ *     <td>The executable function of an action, invoked by the
 *         MTAPI runtime when a task is started.</td>
 *   </tr>
 *   <tr>

--- a/mtapi_cpp/include/embb/mtapi/action.h
+++ b/mtapi_cpp/include/embb/mtapi/action.h
@@ -51,13 +51,13 @@ class Action {
  }
  /**
-    * Constructs an Action from any entity that provides an
+    * Constructs an Action from a function object.
-    * operator() (TaskContext &).
+    *
+    * \tparam Function Function object
    */
  template <typename Function>
  Action(
-    Function func                      /**< [in] Anything that provides an
+    Function func                      /**< [in] Function object */
-                                            operator() (TaskContext &). */
    )
    : function_(func)
    , execution_policy_() {
@@ -65,13 +65,13 @@ class Action {
  }
  /**
-    * Constructs an Action from any entity that provides an
+    * Constructs an Action from a function object and an Affinity.
-    * operator() (TaskContext &) and an Affinity.
+    *
+    * \tparam Function Function object
    */
  template <typename Function>
  Action(
-    Function func,                     /**< [in] Anything that provides an
+    Function func,                     /**< [in] Function object */
-                                            operator() (TaskContext &). */
    ExecutionPolicy execution_policy   /**< [in] Execution policy */
    )
    : function_(func)

--- a/mtapi_cpp/include/embb/mtapi/execution_policy.h
+++ b/mtapi_cpp/include/embb/mtapi/execution_policy.h
@@ -106,6 +106,13 @@ class ExecutionPolicy{
    );
  /**
+   * Returns the number of cores the policy is affine to.
+   *
+   * \return the number of cores
+   */
+  unsigned int GetCoreCount() const;
+  /**
   * Returns the affinity
   *
   * \return the affinity

--- a/mtapi_cpp/include/embb/mtapi/node.h
+++ b/mtapi_cpp/include/embb/mtapi/node.h
@@ -129,6 +129,15 @@ class Node {
  }
  /**
+    * Returns the number of worker threads.
+    * \return The number of worker threads.
+    * \waitfree
+    */
+  mtapi_uint_t GetWorkerThreadCount() const {
+    return worker_thread_count_;
+  }
+  /**
    * Creates a Group to launch \link Task Tasks \endlink in.
    * \return A reference to the created Group
    * \throws ErrorException if the Group object could not be constructed.
@@ -210,6 +219,7 @@ class Node {
    mtapi_task_context_t * context);
  mtapi_uint_t core_count_;
+  mtapi_uint_t worker_thread_count_;
  mtapi_action_hndl_t action_handle_;
  std::list<Queue*> queues_;
  std::list<Group*> groups_;

--- a/mtapi_cpp/src/execution_policy.cc
+++ b/mtapi_cpp/src/execution_policy.cc
@@ -27,6 +27,7 @@
 #include <embb/mtapi/execution_policy.h>
 #include <embb/mtapi/mtapi.h>
 #include <embb/base/exceptions.h>
+#include <embb/base/c/internal/bitset.h>
 #include <cassert>
 namespace embb {
@@ -105,6 +106,10 @@ bool ExecutionPolicy::IsSetWorker(mtapi_uint_t worker) {
  return MTAPI_TRUE == aff;
 }
+unsigned int ExecutionPolicy::GetCoreCount() const {
+  return embb_bitset_count(&affinity_);
+}
 const mtapi_affinity_t &ExecutionPolicy::GetAffinity() const {
  return affinity_;
 }

--- a/mtapi_cpp/src/node.cc
+++ b/mtapi_cpp/src/node.cc
@@ -75,6 +75,7 @@ Node::Node(
      "mtapi::Node could not initialize mtapi");
  }
  core_count_ = info.hardware_concurrency;
+  worker_thread_count_ = embb_core_set_count(&attr->core_affinity);
  action_handle_ = mtapi_action_create(MTAPI_CPP_TASK_JOB, action_func,
    MTAPI_NULL, 0, MTAPI_NULL, &status);
  if (MTAPI_SUCCESS != status) {

--- a/partest.tar
+++ b/partest.tar