mainprogram.cpp

#include <iostream>
#include <vector>
#include <string>
#include <mutex>
#include <thread>
#include <fstream>
#include <sstream>
#include <chrono>
#include <format>

class OptimizedDataStructure {
public:
    OptimizedDataStructure() : data(2, 0) {}

    int read(int index) {
        if (index == 0) {
            std::lock_guard<std::mutex> lock(mutex0_);
            return data[0];
        }
        else {
            std::lock_guard<std::mutex> lock(mutex1_);
            return data[1];
        }
    }

    void write(int index, int value) {
        if (index == 0) {
            std::lock_guard<std::mutex> lock(mutex0_);
            data[0] = value;
        }
        else {
            std::lock_guard<std::mutex> lock(mutex1_);
            data[1] = value;
        }
    }

    explicit operator std::string() {
        std::scoped_lock lock(mutex0_, mutex1_);

        return std::format("[field0={}, field1={}]", data[0], data[1]);
    }

private:
    std::vector<int> data;
    std::mutex mutex0_;
    std::mutex mutex1_;
};

void execute_commands(OptimizedDataStructure& ds, const std::string& filename) {
    std::ifstream file(filename);
    if (!file.is_open()) {
        std::cerr << "Error: Could not read file " << filename << " in thread." << std::endl;
        std::cerr << "Please run the 'generator' program first to create files." << std::endl;
        return;
    }

    std::string line;
    while (std::getline(file, line)) {
        std::stringstream ss(line);
        std::string cmd;
        ss >> cmd;

        if (cmd == "read") {
            int index;
            ss >> index;
            volatile int val = ds.read(index);
        }
        else if (cmd == "write") {
            int index, value;
            ss >> index >> value;
            ds.write(index, value);
        }
        else if (cmd == "string") {
            volatile std::string s = (std::string)ds;
        }
    }
}

double run_test(const std::string& test_name, const std::string& file_prefix, int num_threads) {
    OptimizedDataStructure ds;
    std::vector<std::thread> threads;

    auto start_time = std::chrono::high_resolution_clock::now();

    for (int i = 0; i < num_threads; ++i) {
        std::string filename = file_prefix + "_" + std::to_string(i) + ".txt";
        threads.emplace_back(execute_commands, std::ref(ds), filename);
    }

    for (auto& t : threads) {
        t.join();
    }

    auto end_time = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> duration = end_time - start_time;

    std::cout << std::format("Test '{}' ({} thread/s): {:.2f} ms\n",
        test_name, num_threads, duration.count());

    return duration.count();
}

int main() {
    std::cout << "Starting measurements..." << std::endl;
    std::cout << "Make sure files (a_*.txt, b_*.txt, c_*.txt) are generated." << std::endl;
    std::cout << "---------------------------------" << std::endl;


    double results[3][3];

    results[0][0] = run_test("Scenario A (Variant)", "a", 1);
    results[0][1] = run_test("Scenario A (Variant)", "a", 2);
    results[0][2] = run_test("Scenario A (Variant)", "a", 3);
    std::cout << "---------------------------------" << std::endl;

    results[1][0] = run_test("Scenario B (Uniform)", "b", 1);
    results[1][1] = run_test("Scenario B (Uniform)", "b", 2);
    results[1][2] = run_test("Scenario B (Uniform)", "b", 3);
    std::cout << "---------------------------------" << std::endl;

    results[2][0] = run_test("Scenario C (Anti-Pattern)", "c", 1);
    results[2][1] = run_test("Scenario C (Anti-Pattern)", "c", 2);
    results[2][2] = run_test("Scenario C (Anti-Pattern)", "c", 3);
    std::cout << "---------------------------------" << std::endl;

    std::cout << "\nSummary table for report (in ms):" << std::endl;

    std::cout << std::format("{:<25} {:>15} {:>15} {:>15}\n",
        "Scenario", "1 thread", "2 threads", "3 threads");
    std::cout << std::string(70, '-') << std::endl;

    std::cout << std::format("{:<25} {:>15.2f} {:>15.2f} {:>15.2f}\n",
        "A (Variant)",
        results[0][0], results[0][1], results[0][2]);

    std::cout << std::format("{:<25} {:>15.2f} {:>15.2f} {:>15.2f}\n",
        "B (Uniform)",
        results[1][0], results[1][1], results[1][2]);

    std::cout << std::format("{:<25} {:>15.2f} {:>15.2f} {:>15.2f}\n",
        "C (Anti-Pattern)",
        results[2][0], results[2][1], results[2][2]);

    return 0;
}