OS-LABS/2/main.cpp

#include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <random>
#include <sstream>
#include <stdexcept>
#include <string>
#include <sys/time.h>
#include <unistd.h>      // ✅ getpid
#include <pthread.h>
#include <vector>

// ================= CONFIG =================
constexpr int kDefaultN = 20000;
constexpr int kPreviewCount = 20;

// ================= GLOBALS =================
int active_threads = 0;
int max_threads = 4;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

// ================= TIME =================
double get_time() {
    timeval tv{};
    gettimeofday(&tv, nullptr);
    return tv.tv_sec + tv.tv_usec * 1e-6;
}

std::string now() {
    timeval tv{};
    gettimeofday(&tv, nullptr);

    std::ostringstream oss;
    oss << tv.tv_sec << "." << std::setfill('0') << std::setw(6) << tv.tv_usec;
    return oss.str();
}

// ================= LOG =================
void log_start(int l, int r, int depth) {
    std::cout << "START PID=" << getpid()
              << " TID=" << pthread_self()
              << " depth=" << depth
              << " range=[" << l << "," << r << "] time=" << now() << '\n';
}

void log_end(int l, int r, int depth) {
    std::cout << "END   PID=" << getpid()
              << " TID=" << pthread_self()
              << " depth=" << depth
              << " range=[" << l << "," << r << "] time=" << now() << '\n';
}

// ================= MERGE =================
void merge_range(int* arr, int l, int m, int r) {
    std::vector<int> temp;
    temp.reserve(r - l + 1);

    int i = l;
    int j = m + 1;

    while (i <= m && j <= r) {
        if (arr[i] <= arr[j]) temp.push_back(arr[i++]);
        else temp.push_back(arr[j++]);
    }

    while (i <= m) temp.push_back(arr[i++]);
    while (j <= r) temp.push_back(arr[j++]);

    std::copy(temp.begin(), temp.end(), arr + l);
}

// ================= LOCAL SORT =================
void local_sort(int* arr, int l, int r) {
    if (l >= r) return;

    int m = l + (r - l) / 2;
    local_sort(arr, l, m);
    local_sort(arr, m + 1, r);
    merge_range(arr, l, m, r);
}

// ================= THREAD ARGS =================
struct Args {
    int* arr;
    int l;
    int r;
    int depth;
};

// forward
void parallel_sort(int* arr, int l, int r, int depth);

// ================= THREAD FUNC =================
void* thread_func(void* arg) {
    Args* a = (Args*)arg;
    parallel_sort(a->arr, a->l, a->r, a->depth);
    delete a;
    return nullptr;
}

// ================= PARALLEL SORT =================
void parallel_sort(int* arr, int l, int r, int depth) {
    log_start(l, r, depth);

    if (l >= r) {
        log_end(l, r, depth);
        return;
    }

    int m = l + (r - l) / 2;

    pthread_t tid;
    bool spawned = false;

    // ===== ограничение потоков =====
    pthread_mutex_lock(&mutex);
    if (active_threads < max_threads) {
        active_threads++;
        spawned = true;
    }
    pthread_mutex_unlock(&mutex);

    if (spawned) {
        // правая часть → новый поток
        Args* args = new Args{arr, m + 1, r, depth + 1};
        pthread_create(&tid, nullptr, thread_func, args);

        // левая → текущий поток
        parallel_sort(arr, l, m, depth + 1);

        // ждём
        pthread_join(tid, nullptr);

        pthread_mutex_lock(&mutex);
        active_threads--;
        pthread_mutex_unlock(&mutex);

    } else {
        // без потоков
        parallel_sort(arr, l, m, depth + 1);
        parallel_sort(arr, m + 1, r, depth + 1);
    }

    merge_range(arr, l, m, r);

    log_end(l, r, depth);
}

// ================= UTILS =================
bool parse_positive_int(const char* value, int& out) {
    try {
        size_t consumed = 0;
        int parsed = std::stoi(value, &consumed);
        if (value[consumed] != '\0' || parsed < 0) return false;
        out = parsed;
        return true;
    } catch (...) {
        return false;
    }
}

// ================= MAIN =================
int main(int argc, char* argv[]) {
    int n = kDefaultN;

    if (argc >= 2 && !parse_positive_int(argv[1], n)) {
        std::cerr << "Invalid array size\n";
        return 1;
    }

    if (argc >= 3 && !parse_positive_int(argv[2], max_threads)) {
        std::cerr << "Invalid max_threads\n";
        return 1;
    }

    std::vector<int> arr(n);

    std::mt19937 rng(std::random_device{}());
    std::uniform_int_distribution<int> dist(0, 99999);

    for (int i = 0; i < n; ++i) arr[i] = dist(rng);

    std::cout << "Before:\n";
    for (int i = 0; i < std::min(n, kPreviewCount); ++i)
        std::cout << arr[i] << ' ';
    std::cout << "\n\n";

    double t1 = get_time();

    parallel_sort(arr.data(), 0, n - 1, 0);

    double t2 = get_time();

    std::cout << "\nAfter:\n";
    for (int i = 0; i < std::min(n, kPreviewCount); ++i)
        std::cout << arr[i] << ' ';
    std::cout << '\n';

    std::cout << "\nTime: " << (t2 - t1) << " sec\n";

    return 0;
}