main.cpp

#include <unistd.h>
#include <sys/wait.h>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <chrono>

using duration = std::chrono::duration<double, std::milli>;
using custom_clock = std::chrono::high_resolution_clock;


long long int iter_fibo(int);
long long int rec_fibo(int);

int main(int argc, char** argv){
    pid_t pid;
    int status;
    int p_rec[2], p_iter[2];
    int p_rec_f[2], p_iter_f[2];
    pipe(p_rec); pipe(p_iter);
    pipe(p_rec_f); pipe(p_iter_f);

    for (int i = 0; i < 3; ++i){
        pid = fork();
        if (pid == 0 && i == 0){
            int fibo_number = 0;
            if (argc >= 2){
                fibo_number = std::strtol(argv[1], NULL, 10);
            }
            if (fibo_number == 0) {
                std::cout << "Enter in a number:\n";
                std::cin >> fibo_number;
            }
            write(p_rec[1], &fibo_number, sizeof(int));
            write(p_iter[1], &fibo_number, sizeof(int));

            long long int result_iter;
            duration difference_iter;
            read(p_iter_f[0], &result_iter, sizeof(long long int));
            read(p_iter_f[0], &difference_iter, sizeof(duration));
            std::cout << "Iterative Fibo result: " << result_iter << '\n';
            std::cout << "Time (in milliseconds): " << difference_iter.count() << '\n';

            long long int result_rec;
            duration difference_rec;
            read(p_rec_f[0], &result_rec, sizeof(long long int));
            read(p_rec_f[0], &difference_rec, sizeof(duration));
            std::cout << "Recursive Fibo result: " << result_rec << '\n';
            std::cout << "Time (in milliseconds): " << difference_rec.count() << '\n';

            close(p_rec[0]); close(p_rec[1]);
            close(p_iter[0]); close(p_iter[1]);
            close(p_rec_f[0]); close(p_rec_f[1]);
            close(p_iter_f[0]); close(p_iter_f[1]);
            exit(0);
        } else if (pid == 0 && i == 1){
            int fibo_number;
            read(p_rec[0], &fibo_number, sizeof(int));
            auto start = custom_clock::now();
            long long int result = rec_fibo(fibo_number);
            auto finish = custom_clock::now();
            duration difference = finish - start;
            write(p_rec_f[1], &result, sizeof(long long int));
            write(p_rec_f[1], &difference, sizeof(duration));

            close(p_rec[0]); close(p_rec[1]);
            close(p_iter[0]); close(p_iter[1]);
            close(p_rec_f[0]); close(p_rec_f[1]);
            close(p_iter_f[0]); close(p_iter_f[1]);
            exit(0);
        } else if (pid == 0 && i == 2){
            int fibo_number;
            read(p_iter[0], &fibo_number, sizeof(int));
            auto start = custom_clock::now();
            long long int result = iter_fibo(fibo_number);
            auto finish = custom_clock::now();
            duration difference = finish - start;
            write(p_iter_f[1], &result, sizeof(long long int));
            write(p_iter_f[1], &difference, sizeof(duration));

            close(p_rec[0]); close(p_rec[1]);
            close(p_iter[0]); close(p_iter[1]);
            close(p_rec_f[0]); close(p_rec_f[1]);
            close(p_iter_f[0]); close(p_iter_f[1]);
            exit(0);
        }
    }

    for (int i = 1; i <= 3; ++i){
        pid = wait(&status);
    }
    return 0;
}

long long int iter_fibo(int n){
    if (n <= 0){
        return 0;
    }
    long long int previous = 0;
    long long int result = 1;
    while(n > 1){
        long long int new_prev = result;
        result = result + previous;
        previous = new_prev;
        --n;
    }
    return result;
}

long long int rec_fibo(int n){
    if (n <= 0){
        return 0;
    } else if (n == 1){
        return 1;
    } else {
        return rec_fibo(n-1) + rec_fibo(n-2);
    }
}