Merge branch 'mthreadpool' into 'master'

Refactor thread code

See merge request !1070

mace/utils/thread_pool.cc

@@ -175,7 +175,7 @@ void ThreadPool::Run(const std::function<void(const int64_t)> &func,
   for (size_t i = 0; i < thread_count; ++i) {
     int64_t count = iters_per_thread + (static_cast<int64_t>(i) < remainder);
     thread_infos_[i].range_start = iters_offset;
-    int64_t range_end = std::min(iterations, iters_offset + count);
+    int64_t range_end = iters_offset + count;
     thread_infos_[i].range_end = range_end;
     thread_infos_[i].range_len = range_end - iters_offset;
     thread_infos_[i].func = reinterpret_cast<uintptr_t>(&func);
@@ -306,7 +306,7 @@ void ThreadPool::Compute1D(const std::function<void(int64_t,
     return;
   }
 
-  int64_t items = 1 + (end - start - 1) / step;
+  const int64_t items = 1 + (end - start - 1) / step;
   if (threads_.size() <= 1 || (cost_per_item >= 0
       && items * cost_per_item < kMaxCostUsingSingleThread)) {
     func(start, end, step);
@@ -317,11 +317,11 @@ void ThreadPool::Compute1D(const std::function<void(int64_t,
     tile_size = std::max(static_cast<int64_t>(1), items / default_tile_count_);
   }
 
-  int64_t step_tile_size = step * tile_size;
-  int64_t tile_count = RoundUpDiv(items, tile_size);
-  Run([&](int64_t tile_idx) {
-    int64_t tile_start = start + tile_idx * step_tile_size;
-    int64_t tile_end = std::min(end, tile_start + step_tile_size);
+  const int64_t step_tile_size = step * tile_size;
+  const int64_t tile_count = RoundUpDiv(items, tile_size);
+  Run([=](int64_t tile_idx) {
+    const int64_t tile_start = start + tile_idx * step_tile_size;
+    const int64_t tile_end = std::min(end, tile_start + step_tile_size);
     func(tile_start, tile_end, step);
   }, tile_count);
 }
@@ -345,8 +345,8 @@ void ThreadPool::Compute2D(const std::function<void(const int64_t,
     return;
   }
 
-  int64_t items0 = 1 + (end0 - start0 - 1) / step0;
-  int64_t items1 = 1 + (end1 - start1 - 1) / step1;
+  const int64_t items0 = 1 + (end0 - start0 - 1) / step0;
+  const int64_t items1 = 1 + (end1 - start1 - 1) / step1;
   if (threads_.size() <= 1 || (cost_per_item >= 0
       && items0 * items1 * cost_per_item < kMaxCostUsingSingleThread)) {
     func(start0, end0, step0, start1, end1, step1);
@@ -364,18 +364,18 @@ void ThreadPool::Compute2D(const std::function<void(const int64_t,
     }
   }
 
-  int64_t step_tile_size0 = step0 * tile_size0;
-  int64_t step_tile_size1 = step1 * tile_size1;
-  int64_t tile_count0 = RoundUpDiv(items0, tile_size0);
-  int64_t tile_count1 = RoundUpDiv(items1, tile_size1);
-
-  Run([&](int64_t tile_idx) {
-    int64_t tile_idx0 = tile_idx / tile_count1;
-    int64_t tile_idx1 = tile_idx - tile_idx0 * tile_count1;
-    int64_t tile_start0 = start0 + tile_idx0 * step_tile_size0;
-    int64_t tile_end0 = std::min(end0, tile_start0 + step_tile_size0);
-    int64_t tile_start1 = start1 + tile_idx1 * step_tile_size1;
-    int64_t tile_end1 = std::min(end1, tile_start1 + step_tile_size1);
+  const int64_t step_tile_size0 = step0 * tile_size0;
+  const int64_t step_tile_size1 = step1 * tile_size1;
+  const int64_t tile_count0 = RoundUpDiv(items0, tile_size0);
+  const int64_t tile_count1 = RoundUpDiv(items1, tile_size1);
+
+  Run([=](int64_t tile_idx) {
+    const int64_t tile_idx0 = tile_idx / tile_count1;
+    const int64_t tile_idx1 = tile_idx - tile_idx0 * tile_count1;
+    const int64_t tile_start0 = start0 + tile_idx0 * step_tile_size0;
+    const int64_t tile_end0 = std::min(end0, tile_start0 + step_tile_size0);
+    const int64_t tile_start1 = start1 + tile_idx1 * step_tile_size1;
+    const int64_t tile_end1 = std::min(end1, tile_start1 + step_tile_size1);
     func(tile_start0, tile_end0, step0, tile_start1, tile_end1, step1);
   }, tile_count0 * tile_count1);
 }
@@ -406,9 +406,9 @@ void ThreadPool::Compute3D(const std::function<void(const int64_t,
     return;
   }
 
-  int64_t items0 = 1 + (end0 - start0 - 1) / step0;
-  int64_t items1 = 1 + (end1 - start1 - 1) / step1;
-  int64_t items2 = 1 + (end2 - start2 - 1) / step2;
+  const int64_t items0 = 1 + (end0 - start0 - 1) / step0;
+  const int64_t items1 = 1 + (end1 - start1 - 1) / step1;
+  const int64_t items2 = 1 + (end2 - start2 - 1) / step2;
   if (threads_.size() <= 1 || (cost_per_item >= 0
       && items0 * items1 * items2 * cost_per_item
           < kMaxCostUsingSingleThread)) {
@@ -423,7 +423,7 @@ void ThreadPool::Compute3D(const std::function<void(const int64_t,
       tile_size2 = items2;
     } else {
       tile_size0 = 1;
-      int64_t items01 = items1 * items0;
+      const int64_t items01 = items1 * items0;
       if (items01 >= default_tile_count_) {
         tile_size1 = items01 / default_tile_count_;
         tile_size2 = items2;
@@ -435,25 +435,25 @@ void ThreadPool::Compute3D(const std::function<void(const int64_t,
     }
   }
 
-  int64_t step_tile_size0 = step0 * tile_size0;
-  int64_t step_tile_size1 = step1 * tile_size1;
-  int64_t step_tile_size2 = step2 * tile_size2;
-  int64_t tile_count0 = RoundUpDiv(items0, tile_size0);
-  int64_t tile_count1 = RoundUpDiv(items1, tile_size1);
-  int64_t tile_count2 = RoundUpDiv(items2, tile_size2);
-  int64_t tile_count12 = tile_count1 * tile_count2;
-
-  Run([&](int64_t tile_idx) {
-    int64_t tile_idx0 = tile_idx / tile_count12;
-    int64_t tile_idx12 = tile_idx - tile_idx0 * tile_count12;
-    int64_t tile_idx1 = tile_idx12 / tile_count2;
-    int64_t tile_idx2 = tile_idx12 - tile_idx1 * tile_count2;
-    int64_t tile_start0 = start0 + tile_idx0 * step_tile_size0;
-    int64_t tile_end0 = std::min(end0, tile_start0 + step_tile_size0);
-    int64_t tile_start1 = start1 + tile_idx1 * step_tile_size1;
-    int64_t tile_end1 = std::min(end1, tile_start1 + step_tile_size1);
-    int64_t tile_start2 = start2 + tile_idx2 * step_tile_size2;
-    int64_t tile_end2 = std::min(end2, tile_start2 + step_tile_size2);
+  const int64_t step_tile_size0 = step0 * tile_size0;
+  const int64_t step_tile_size1 = step1 * tile_size1;
+  const int64_t step_tile_size2 = step2 * tile_size2;
+  const int64_t tile_count0 = RoundUpDiv(items0, tile_size0);
+  const int64_t tile_count1 = RoundUpDiv(items1, tile_size1);
+  const int64_t tile_count2 = RoundUpDiv(items2, tile_size2);
+  const int64_t tile_count12 = tile_count1 * tile_count2;
+
+  Run([=](int64_t tile_idx) {
+    const int64_t tile_idx0 = tile_idx / tile_count12;
+    const int64_t tile_idx12 = tile_idx - tile_idx0 * tile_count12;
+    const int64_t tile_idx1 = tile_idx12 / tile_count2;
+    const int64_t tile_idx2 = tile_idx12 - tile_idx1 * tile_count2;
+    const int64_t tile_start0 = start0 + tile_idx0 * step_tile_size0;
+    const int64_t tile_end0 = std::min(end0, tile_start0 + step_tile_size0);
+    const int64_t tile_start1 = start1 + tile_idx1 * step_tile_size1;
+    const int64_t tile_end1 = std::min(end1, tile_start1 + step_tile_size1);
+    const int64_t tile_start2 = start2 + tile_idx2 * step_tile_size2;
+    const int64_t tile_end2 = std::min(end2, tile_start2 + step_tile_size2);
     func(tile_start0,
          tile_end0,
          step0,