Proof-Of-Concept: Shared Memory + transact kernel module

Shared memory is significantly faster than communicating through named
pipes, mainly since you have to do two copies of the data: once to get
it into a kernel buffer and another one to get it out and into the other
process. The problem with shared memory is that it needs extra
synchronization that is tricky to get right and sandbox without allowing
too many extra syscalls (for instance, futex would be needed, which is
kind of scary). Plus, getting death notifications is hard with
semaphores.

One realistic option is to use named pipes to do signalling only, but
since I was kind of into delving deeper into the kernel, I made a kernel
module that achieves that with no extra sandbox modifications[1], and is
slightly faster than named pipes, semaphores or eventfd since you only
need one syscall to switch between processes, so that saves ~100ns from
every message sent.

Combining shared memory with super fast signalling and forcing the
affinity of both processes to run on the same CPU core makes performance
a _lot_ better. Running the slowest case of Caves[2] used to take 0.706s
user (2.796s wall) and now takes 0.439s user (0.958s wall). For
comparison, the deprecated style of linking both programs into the same
processes takes 0.664s for both user and wall.

[1]: https://github.com/lhchavez/transact
[2]: https://omegaup.com/arena/problem/cave/