Алгоритм для многопоточности

#include <QCoreApplication>
#include <QTime>
#include <QDebug>
#include "FindMaxInArrayThread.h"
 
struct Range
{
    Range(size_t start, size_t length);
 
    size_t mStart;
    size_t mLength;
};
 
Range::Range(size_t start, size_t length)
    : mStart(start)
    , mLength(length)
{}
 
void PrintRanges(const std::vector<Range>& ranges)
{
    for (size_t index = 0; index < ranges.size(); ++index)
    {
        qDebug()<< ranges[index].mStart << "," << ranges[index].mLength;
    }
}
 
std::vector<Range> GenerateRanges(size_t numElements, size_t numRanges)
{
    std::vector<Range> ranges;
    ranges.reserve(numRanges);
 
    const size_t minLength = numElements / numRanges;
    const size_t modulo = numElements % numRanges;
 
    for (size_t index = 0; index < modulo; ++index)
        ranges.push_back(Range(0, minLength + 1));
 
    for (size_t index = modulo; index < numRanges; ++index)
        ranges.push_back(Range(0, minLength));
 
    for (size_t index = 1; index < numRanges; ++index)
        ranges[index].mStart = ranges[index - 1].mStart + ranges[index - 1].mLength;
 
    return ranges;
}
 
void FindMax(const int elements[], const size_t numElements, const size_t numThreads)
{
    QTime time(QTime::currentTime());
    std::srand(time.msecsSinceStartOfDay());
 
    std::vector<QThread*> threads;
    threads.reserve(numThreads);
 
    std::vector<int> results(numThreads);
 
    const std::vector<Range> ranges = GenerateRanges(numElements, numThreads);
    for (size_t index = 0; index < numThreads; ++index)
        threads.push_back(new FindMaxInArrayThread(&elements[0], ranges[index].mStart, ranges[index].mLength, &results[index]));
 
    time.start();
    for (size_t index = 0; index < numThreads; ++index)
        threads[index]->start();
 
    for (size_t index = 0; index < numThreads; ++index)
        threads[index]->wait();
 
    const int maxValue = *std::max_element(results.begin(), results.end());
    const int elapsedMs = time.elapsed();
 
    qDebug() << "Elapsed time(ms): " << elapsedMs;
    qDebug() << "Result: " << maxValue << "\n";
 
    for (size_t index = 0; index < numThreads; ++index)
        delete threads[index];
}
 
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
 
    const size_t numElements  = 100000000;
    std::vector<int> elements;
    elements.reserve(numElements);
 
    for (size_t index = 0; index < numElements; ++index)
        elements.push_back(std::rand() % numElements);
 
    int  idealThreadCount = QThread::idealThreadCount();
 
    qDebug() << "One Thread:";
    FindMax(&elements[0], numElements, 1);
 
    qDebug() << "Two Thread:";
    FindMax(&elements[0], numElements, 2);
 
    qDebug() << "Optimal Thread: ";
    qDebug() <<"Ideal Thread Count:" << idealThreadCount;
    FindMax(&elements[0], numElements, idealThreadCount);
 
    qDebug() << "Twenty Thread: ";
    FindMax(&elements[0], numElements, 20);
    return app.exec();
}