#include <iostream>
#include <sys/mman.h>
#include <boost/date_time.hpp>
#include <boost/interprocess/sync/interprocess_mutex.hpp>
#include <boost/interprocess/sync/interprocess_condition.hpp>

using namespace std;

size_t N = 100000;

using ipc_mutex = boost::interprocess::interprocess_mutex;
using ipc_cond_var = boost::interprocess::interprocess_condition;

struct IPC
{
    ipc_mutex mtx;
    ipc_cond_var cond_arg;
    ipc_cond_var cond_ret;
    size_t arg;
    size_t ret;
    bool done{true};
};

size_t send_call(IPC* ipc, size_t arg)
{
    boost::unique_lock<ipc_mutex> lock(ipc->mtx);
    ipc->arg = arg;
    ipc->done = false;
    ipc->cond_arg.notify_one();
    while (!ipc->done) {
        ipc->cond_ret.wait(lock);
    }
    return ipc->ret;
}

size_t handle_call(IPC* ipc)
{
    boost::unique_lock<ipc_mutex> lock(ipc->mtx);
    while (ipc->done) {
        ipc->cond_arg.wait(lock);
    }
    ipc->ret = ipc->arg + 1;
    ipc->done = true;
    ipc->cond_ret.notify_one();
    return ipc->ret;
}

void callee(IPC* ipc)
{
    while (1) {
        if (handle_call(ipc) == N)
            break;
    }
}

void caller(IPC* ipc)
{
    for (size_t i = 0; i < N; i++) {
        if (send_call(ipc, i) != i + 1)
            throw std::runtime_error("invalid call");
    }
}

int main(/*int argc, char* argv[]*/)
{
    IPC* ipc = (IPC*) mmap(nullptr, sizeof(IPC), PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
    if (!ipc)
        throw std::runtime_error("mmap failed");
    new (ipc) IPC;
    auto t1 = boost::posix_time::microsec_clock::universal_time();
    if (fork() == 0) {
        // child
        callee(ipc);
    }
    else {
        // parent
        caller(ipc);
        auto t2 = boost::posix_time::microsec_clock::universal_time();
        auto dur = t2 - t1;
        cout << "perf=" << (double)N / dur.total_milliseconds() << " K/s" << endl;
    }
    return 0;
}