Add some benchmarks for the filesystem datastore

[ntninja]

…and possibly improve the code if there any major bottlenecks.

[ntninja]

So I made some headway into benchmarking the filesystem datastore and the initial results didn't look all that great. The greatest single surprise was just how huge the thread-switching overhead for AIO is.

I've done some experimentation on this and the following techniques seem to help:

1. Put everything you can into single big worker thread calls
   • At the start of put only some very basic checks remain on the main thread and then everything that can possibly be done on the I/O thread is performed in a single function run using blocking I/O on that thread
   • The basic setup I experimented with was to subdivide a put into exactly three phases: setup (first thread-switch – do everything before receiving actual data), n-times write (one thread-switch per received data chunk), cleanup (final thread-switch – close file and do whatever booking that is necessary)
   • → Up 100% performance increase (depending on number of context switches saved)
2. Stream data to threads using pipes
   • It turns out the thread-switching is so bad that even going with a setup, write, cleanup cycle above is actually slower than this alternate approach:
     1. Create an anonymous pipe (using os.pipe)
     2. Start a single background worker thread and pass it the read end of the pipe
     3. Copy each received data chunk received through trio streams into the OS pipe
     4. Have the background thread block on the read end of the pipe and copy the data again into the target output file
   • On measurements this about 20% faster (on Linux at least) than doing the equivalent setup, write, cleanup cycle from above – at least for a single write, with 10 disinct writes it was already 44% faster.
3. Possible further optimization: If the data is already known by the time ._put is called (because a bytes object was passed to .put) we directly pass it to the worker thread on thread start.