Filechannel implementation

[manticore-projects]

Greetings!

First of all, I want to apologise upfront when it looks like I have hijacked your project. This is not my intention but I have working on too much stuff in parallel and it was easier to work on this in a kind of a forked environment. My goal is to feed every bit back into the main project and make JUring successful.

Now, please have a look at https://github.com/manticore-projects/JUring/tree/filechannel
It contains a complete FileChannel based on JUring with promising benchmarks.

My goal is to provide a FileChannel implementation to the H2 Java File database in order to speed up IO operations.
So the major benchmarks simulate Database patterns. Although there is also a transferFrom and transferTo benchmark showing JUring ahead for larger blocks.

Important: All benchmarks are done for D_OPEN for both JUringFileChannel and Standard FileChannel to make it comparable. So you will need to run those benchmarks on a EXT4 or XFS filesystem (but not on TEMPFS or encrypted/compressing FS). Please set the System Environment Variable JURING_TEST_DIR=... accordingly.

What has been added:

• added some methods to JUring to allow writing fixed buffers by buffer reference

• added an atomic ID generator for avoiding duplicates (also faster)

• added a special C module for encapsulating a series of libUring calls to avoid a series of Panama roundtrips with overhead

• added a full JUringFileChannel implementation with Asynchronous Batch Read/Write (via JUring API) and Full Asynchronous Batch Read/Write (via additional C module)

• added support for transferTo, transferFrom, lock, tryLock and force etc.

• added comprehensive benchmarks w/ graphical output

• added correctness tests

• fixed the existing tests and benchmark (e.g. avoid hard coded file locations)

• introduced a Gradle build file (sorry, I hate Maven and need to gradle scripting capabilities)

• added Maven publishing capabilities w/ versions directly derived from GIT tags (Snaphot builds vs. Releases)

Probably some more stuff I have forgotten.
Please do let me know what you think and how you will want to move forward (but be mild on me, since it was a lot of work and I am just an accountant).

Best and cheers!

[manticore-projects]

1 Page = 8k bytes, all O_DIRECT to eliminate cache effects.

Pages       Mode                                      Median(ms)  ops/ms      MB/s      
--------------------------------------------------------------------------------------------------------------
10          Standard O_DIRECT                             0.26 ms     3.836         300
10          Standard O_DIRECT + DSYNC                     7.36 ms     0.136          11
10          JUring sync                                   0.68 ms     1.471         115
10          JUring writeFullyBatch                        0.13 ms     7.457         583

100         Standard O_DIRECT                             2.04 ms     0.491         384
100         Standard O_DIRECT + DSYNC                    73.60 ms     0.014          11
100         JUring sync                                   2.16 ms     0.464         362
100         JUring writeFullyBatch                        0.65 ms     1.534        1198

500         Standard O_DIRECT                            10.12 ms     0.099         386
500         Standard O_DIRECT + DSYNC                   369.83 ms     0.003          11
500         JUring sync                                   8.08 ms     0.124         484
500         JUring writeFullyBatch                        3.64 ms     0.275        1073

1000        Standard O_DIRECT                            18.28 ms     0.055         427
1000        Standard O_DIRECT + DSYNC                   740.35 ms     0.001          11
1000        JUring sync                                  16.02 ms     0.062         488
1000        JUring writeFullyBatch                        7.37 ms     0.136        1060


Pages       Mode                                      Median(ms)  ops/ms      MB/s      
--------------------------------------------------------------------------------------------------------------
   Creating 512MB test file...

16          Standard O_DIRECT random read                 1.33 ms     0.754          94
16          JUring sync random read                       1.50 ms     0.667          83
16          JUring readFullyBatch                         0.47 ms     2.145         268

64          Standard O_DIRECT random read                 5.47 ms     0.183          91
64          JUring sync random read                       5.75 ms     0.174          87
64          JUring readFullyBatch                         1.53 ms     0.655         328

256         Standard O_DIRECT random read                21.60 ms     0.046          93
256         JUring sync random read                      22.18 ms     0.045          90
256         JUring readFullyBatch                         5.56 ms     0.180         360

512         Standard O_DIRECT random read                43.13 ms     0.023          93
512         JUring sync random read                      44.04 ms     0.023          91
512         JUring readFullyBatch                        10.93 ms     0.091         366


--- Latency Breakdown (per-phase timing, 100 ops) ---
  
  List<BatchWriteOp> creation:  0.012 ms
  Full writeFullyBatch:         0.827 ms
  -> JUring I/O overhead:       0.816 ms  (prepare + submit + collect)
  
  Standard 100x pwrite64:       1.969 ms
  -> Per pwrite64 cost:         19.688 us

--- Phase-by-Phase BatchDispatcher Timing ---
  Array fill (pre-alloc'd)           0.064 ms  (  0.64 us/op)
  BatchDispatcher.prepare            0.003 ms  (  0.03 us/op)
  submitAndCollect                   0.751 ms  (  7.51 us/op)
  Result check                       0.012 ms  (  0.12 us/op)
  Total end-to-end                   0.823 ms  (  8.23 us/op)     <-- Compare to the 19.688 us/op pwrite64 cost
  Sum of parts                       0.830 ms                     <-- Confirms the 0.65 ms from JUring writeFullyBatch
  Unaccounted (lock/overhead)       -0.007 ms

[davidtos]

Wow! Thank you so much for building all of this! :-)

I really appreciate that you build all of this. It is an impressive amount of work, and it's incredibly cool that you have a FileChannel variant using io_uring.

I want to give this the attention it clearly deserves, but I’m currently in a bit of a time crunch and have almost no availability for the next two weeks. I’m definitely going to look at the benchmarks and the code in more detail as soon as my schedule clears up.

I’m excited to dive in and see how we can merge this back into the main project. Hang tight, and I’ll get back to you as soon as I can!

[manticore-projects]

Thank you so much David, I do appreciate the warm welcome.

Please take all the time you need since this is all proof of concept yet and will be subject to a cleanup and refactoring once we find the most performance patterns.

In the meantime, I am incorporating this into H2 for getting a strong use case. Best and cheers!!