init 2

2/Makefile

@@ -0,0 +1,16 @@
+CXX = g++
+CXXFLAGS = -O2 -std=c++17 -pthread
+
+TARGET = lab2
+SRC = main.cpp
+
+all: $(TARGET)
+
+$(TARGET): $(SRC)
+	$(CXX) $(CXXFLAGS) $< -o $@
+
+run: $(TARGET)
+	./$(TARGET) 20000 4
+
+clean:
+	rm -f $(TARGET)

2/main.cpp

@@ -0,0 +1,203 @@
+#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;
+}