separate 1 done

1/main.cpp

@@ -0,0 +1,212 @@
+#include <algorithm>
+#include <cstdlib>
+#include <iomanip>
+#include <iostream>
+#include <random>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <vector>
+
+namespace {
+
+constexpr int kDefaultN = 20000;
+constexpr int kDefaultMaxDepth = 3;
+constexpr int kPreviewCount = 20;
+
+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();
+}
+
+void log_start(int l, int r, int depth) {
+    std::cout << "START PID=" << getpid() << " PPID=" << getppid() << " depth=" << depth
+              << " range=[" << l << "," << r << "] time=" << now() << '\n'
+              << std::flush;
+}
+
+void log_end(int l, int r, int depth) {
+    std::cout << "END   PID=" << getpid() << " PPID=" << getppid() << " depth=" << depth
+              << " range=[" << l << "," << r << "] time=" << now() << '\n'
+              << std::flush;
+}
+
+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);
+}
+
+void local_sort(int* arr, int l, int r) {
+    if (l >= r) {
+        return;
+    }
+
+    const int m = l + (r - l) / 2;
+    local_sort(arr, l, m);
+    local_sort(arr, m + 1, r);
+    merge_range(arr, l, m, r);
+}
+
+void parallel_sort(int* arr, int l, int r, int depth, int max_depth) {
+    log_start(l, r, depth);
+
+    if (l >= r) {
+        log_end(l, r, depth);
+        return;
+    }
+
+    const int m = l + (r - l) / 2;
+    if (depth >= max_depth) {
+        local_sort(arr, l, r);
+        log_end(l, r, depth);
+        return;
+    }
+
+    pid_t left = fork();
+    if (left == 0) {
+        parallel_sort(arr, l, m, depth + 1, max_depth);
+        _exit(EXIT_SUCCESS);
+    }
+
+    if (left < 0) {
+        std::perror("fork left");
+        local_sort(arr, l, m);
+    }
+
+    pid_t right = fork();
+    if (right == 0) {
+        parallel_sort(arr, m + 1, r, depth + 1, max_depth);
+        _exit(EXIT_SUCCESS);
+    }
+
+    if (right < 0) {
+        std::perror("fork right");
+        local_sort(arr, m + 1, r);
+    }
+
+    int left_status = 0;
+    if (left > 0 && waitpid(left, &left_status, 0) < 0) {
+        std::perror("waitpid left");
+        local_sort(arr, l, m);
+    } else if (left > 0 && (!WIFEXITED(left_status) || WEXITSTATUS(left_status) != 0)) {
+        local_sort(arr, l, m);
+    }
+
+    int right_status = 0;
+    if (right > 0 && waitpid(right, &right_status, 0) < 0) {
+        std::perror("waitpid right");
+        local_sort(arr, m + 1, r);
+    } else if (right > 0 && (!WIFEXITED(right_status) || WEXITSTATUS(right_status) != 0)) {
+        local_sort(arr, m + 1, r);
+    }
+
+    merge_range(arr, l, m, r);
+    log_end(l, r, depth);
+}
+
+bool parse_positive_int(const char* value, int& out) {
+    try {
+        size_t consumed = 0;
+        const int parsed = std::stoi(value, &consumed);
+        if (value[consumed] != '\0') {
+            return false;
+        }
+        if (parsed <= 0) {
+            return false;
+        }
+        out = parsed;
+        return true;
+    } catch (const std::invalid_argument&) {
+        return false;
+    } catch (const std::out_of_range&) {
+        return false;
+    }
+}
+
+}  // namespace
+
+int main(int argc, char* argv[]) {
+    int n = kDefaultN;
+    int max_depth = kDefaultMaxDepth;
+
+    if (argc >= 2 && !parse_positive_int(argv[1], n)) {
+        std::cerr << "Invalid array size: " << argv[1] << '\n';
+        return EXIT_FAILURE;
+    }
+    if (argc >= 3 && !parse_positive_int(argv[2], max_depth)) {
+        std::cerr << "Invalid max depth: " << argv[2] << '\n';
+        return EXIT_FAILURE;
+    }
+
+    const size_t shm_size = static_cast<size_t>(n) * sizeof(int);
+    const int shmid = shmget(IPC_PRIVATE, shm_size, IPC_CREAT | 0600);
+    if (shmid < 0) {
+        std::perror("shmget");
+        return EXIT_FAILURE;
+    }
+
+    int* arr = static_cast<int*>(shmat(shmid, nullptr, 0));
+    if (arr == reinterpret_cast<void*>(-1)) {
+        std::perror("shmat");
+        shmctl(shmid, IPC_RMID, nullptr);
+        return EXIT_FAILURE;
+    }
+
+    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";
+
+    parallel_sort(arr, 0, n - 1, 0, max_depth);
+
+    std::cout << "\nAfter:\n";
+    for (int i = 0; i < std::min(n, kPreviewCount); ++i) {
+        std::cout << arr[i] << ' ';
+    }
+    std::cout << '\n';
+
+    if (shmdt(arr) < 0) {
+        std::perror("shmdt");
+    }
+    if (shmctl(shmid, IPC_RMID, nullptr) < 0) {
+        std::perror("shmctl IPC_RMID");
+    }
+
+    return EXIT_SUCCESS;
+}