#include <iostream>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/wait.h>
#include <unistd.h>
#include <sys/time.h>
#include <cstdlib>

using namespace std;

#define MAX 100000
#define MAX_DEPTH 3

struct SharedData {
    int arr[MAX];
};

// ================= TIME =================
double now() {
    timeval t;
    gettimeofday(&t, NULL);
    return t.tv_sec + t.tv_usec / 1e6;
}

// ================= MERGE =================
void merge(int *arr, int l, int m, int r) {
    int *temp = new int[r - l + 1];

    int i = l, j = m + 1, k = 0;

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

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

    for (int x = 0; x < k; x++)
        arr[l + x] = temp[x];

    delete[] temp;
}

// ================= LOCAL SORT =================
void local_sort(int *arr, int l, int r) {
    if (l >= r) return;
    int m = (l + r) / 2;
    local_sort(arr, l, m);
    local_sort(arr, m + 1, r);
    merge(arr, l, m, r);
}

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

    double start = now();

    pid_t pid = getpid();
    pid_t ppid = getppid();

    cout << "[START] t=" << start
         << " PID=" << pid
         << " PPID=" << ppid
         << " depth=" << depth
         << " range=[" << l << "," << r << "]\n";

    int m = (l + r) / 2;

    if (depth >= MAX_DEPTH) {
        local_sort(arr, l, r);

        double end = now();
        cout << "[END]   t=" << end
             << " PID=" << pid
             << " duration=" << (end - start)
             << " sec\n";
        return;
    }

    pid_t left = fork();

    if (left == 0) {
        parallel_sort(arr, l, m, depth + 1);
        _exit(0);
    }

    pid_t right = fork();

    if (right == 0) {
        parallel_sort(arr, m + 1, r, depth + 1);
        _exit(0);
    }

    waitpid(left, NULL, 0);
    waitpid(right, NULL, 0);

    merge(arr, l, m, r);

    double end = now();

    cout << "[END]   t=" << end
         << " PID=" << pid
         << " duration=" << (end - start)
         << " sec\n";
}

// ================= MAIN =================
int main() {
    key_t key = ftok("shmfile", 65);
    int shmid = shmget(key, sizeof(SharedData), 0666 | IPC_CREAT);

    SharedData *data = (SharedData*) shmat(shmid, (void*)0, 0);

    int n = 20000;

    srand(time(NULL));

    for (int i = 0; i < n; i++)
        data->arr[i] = rand() % 100000;

    double global_start = now();

    cout << "Main PID=" << getpid() << "\n\n";

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

    double global_end = now();

    cout << "\nExecution time: "
         << (global_end - global_start)
         << " sec\n";

    // Проверка
    for (int i = 1; i < n; i++) {
        if (data->arr[i - 1] > data->arr[i]) {
            cout << "ERROR: not sorted!\n";
            break;
        }
    }

    cout << "Sorted correctly\n";

    shmdt(data);
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}