task-unmodified.cpp

/*
    File: task-unmodified.cpp

    g++ -march=native -O2 -std=c++14 -Wall -Wextra -Wshadow -Wconversion -fmax-errors=2 task-unmodified.cpp -o task-unmodified.o
*/

#include <chrono>
#include <thread>
#include <functional>
#include <random>
#include <cassert>
#include <iostream>
#include <numeric>

void matMultVec(double *result, double *mat, unsigned rows, unsigned cols, double *vec) {
     for (unsigned i = 0; i < rows; ++i)
     {
         for (unsigned j = 0; j < cols; ++j)
         {
              result[i] += mat[i*cols + j] * vec[j];
         }
     }
}

class Timer {

    std::chrono::time_point<std::chrono::system_clock> time_point;

    size_t value;

public:

    void start() {
        time_point = std::chrono::system_clock::now();
    }

    void finish() {
        auto curr = std::chrono::system_clock::now();
        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(curr - time_point);
        value = elapsed.count();
    }

    size_t get() const {
        return value;
    }
};



class Producer {
    const unsigned totalJobs;
    unsigned jobsIssued;
    unsigned jobsReady;

    const unsigned jobWidth;
    const unsigned jobHeight;

public:
    Producer(): totalJobs(100), jobsIssued(0), jobsReady(0), jobWidth(1000), jobHeight(2000) {}
    unsigned getTotalJobs() { return totalJobs; }
    std::function<double(void)> getJob()
    {
        assert(jobsIssued < totalJobs);
        if (!jobsReady) {
            std::chrono::milliseconds generationTime(100);
            std::this_thread::sleep_for(generationTime);
            unsigned newJobs = 2;
            if (newJobs + jobsIssued > totalJobs)
            newJobs = totalJobs - jobsIssued;
            jobsReady += newJobs;
            std::clog << "Added " << newJobs << " new jobs." << std::endl;
        }
        jobsReady--;
        jobsIssued++;
        unsigned jobInit = jobsIssued;
        return [jobInit, this] () {
            Timer timer;
            size_t totalMultTime = 0, totalGenTime = 0;
            double sum = 0;
            for (unsigned iter = 0; iter != 10; iter++)
            {
                // Prepare matrix and vector:
                timer.start();
                std::vector<double> matrix(jobWidth*jobHeight);
                for (unsigned i = 0; i != jobWidth*jobHeight; i++)
                {
                    matrix[i] = (0.00001*((jobInit + 10)*(jobInit - iter)) + i*0.02 + 0.1*(jobInit%4))/100000;
                }
                std::vector<double> vec(jobWidth);
                for (unsigned i = 0; i != jobWidth; i++)
                {
                    vec[i] = -(0.0001*((jobInit + 10) - iter) - i*0.01)/1000;
                }
                std::vector<double> result(jobHeight, 0);
                timer.finish();
                totalGenTime += timer.get();
                // Call multiplication:
                timer.start();
                matMultVec(&result[0], &matrix[0], jobHeight, jobWidth, &vec[0]);
                timer.finish();
                totalMultTime += timer.get();
                // Update answer:
                sum += std::accumulate(result.begin(), result.end(), 0)/1000.0;
            }
            std::clog << "Task " << jobInit << " produced " << sum;
            std::clog << ", totalMultTime is " << totalMultTime << " ms";
            std::clog << ", totalGenTime is " << totalGenTime << " ms" << std::endl;
            return sum;
        };
    }
};

int main()
{
    Timer timer;
    timer.start();

    Producer jobSource;
    unsigned jobsLeft = jobSource.getTotalJobs();
    double result = 0;
    while (jobsLeft) {
        auto job = jobSource.getJob();
        result += job();
        jobsLeft--;
    }

    timer.finish();

    std::clog << "Done. Result is " << result << ", working time is " << timer.get() << " ms" << std::endl;
}