A confusion about parallel_accumulate in C++ Concurrency in action

Question

In the following example (Chapter 2), Anthony Williams is trying to parallelize the standard accumulate function. my question is why is he doing this:

   unsigned long const max_threads=(length+min_per_thread-1)/min_per_thread;

why add length and subtract 1? why not just:

 unsigned long const max_threads=length/min_per_thread;

...................................................................................

   template<typename Iterator,typename T>
    struct accumulate_block
    {
           void operator()(Iterator first,Iterator last,T& result)
           {
              result=std::accumulate(first,last,result);
           }
    };


    template<typename Iterator,typename T>
    T parallel_accumulate(Iterator first,Iterator last,T init)
    {
          unsigned long const length=std::distance(first,last);
          if(!length) 
              return init;

          unsigned long const min_per_thread=25;
          unsigned long const max_threads=(length+min_per_thread-1)/min_per_thread; 

          unsigned long const hardware_threads=std::thread::hardware_concurrency();
          unsigned long const num_threads=
          std::min(hardware_threads!=0?hardware_threads:2,max_threads);

         unsigned long const block_size=length/num_threads;   

         std::vector<T> results(num_threads);
         std::vector<std::thread> threads(num_threads-1); 
         Iterator block_start=first;
         for(unsigned long i=0;i<(num_threads-1);++i)
         {
             Iterator block_end=block_start;
             std::advance(block_end,block_size); #6
             threads[i]=std::thread( accumulate_block<Iterator,T>(),     
                              block_start,block_end,std::ref(results[i]));
             block_start=block_end; 
         }
        accumulate_block()(block_start,last,results[num_threads-1]);  
        std::for_each(threads.begin(),threads.end(),
        std::mem_fn(&std::thread::join));

        return std::accumulate(results.begin(),results.end(),init); 
    }

Answer 1

The problem with using

 unsigned long const max_threads=length/min_per_thread;

is caused by the truncation rounding used during integer division

if

length = 7
min_per_thread = 5

then

max_threads = length / min_per_thread = 1

while max threads should actually be 2

length + min_per_thread - 1 = 11

max_threads = (length + min_per_thread - 1) / min_per_thread = 2