perf(jfat): defer FAT flush in FatFile.write to fix per-write sync overhead

FatChain.write() and FatFile.write() called fat.flush() on every single
write() invocation, forcing an O(N) scan of every dirty FatCache element
to the device before the write returned. For sequential and append-heavy
workloads this dropped throughput by an order of magnitude: append ran at
8 MiB/s while the underlying device could sustain 170+ MiB/s.

Removed the two fat.flush() calls inside FatChain.write() and the trailing
flush() in FatFile.write(). The dirty FAT cache, dir entry, and chain are
now persisted lazily by the existing close-path:

  - file.flush()     -> FatEntry.flush() persists dir-entry record
  - fs.flush()       -> flushFiles() + fat.flush() sync the FAT cache
  - fs.close()       -> AbstractFileSystem.close() calls flush() then api.flush()
  - FileHandleImpl.close() -> file.flush()

fat.set() / fat.clearCluster() only mutate the in-memory FatCache, so
the cache continues to expose consistent reads to follow-up writes on
the same fs instance between flushes.

Benchmark (FatWriteBench):
  sequential-write  173 -> 198 MiB/s  (+14%)
  many-small-files  0.53 -> 0.62 MiB/s  (+17%)
  append            8.0 -> 12.4 MiB/s  (+55%)
  append-fsync      4.5 -> 4.9 MiB/s  (+8%)
  create-tree       2.9 -> 3.1 MiB/s  (+7%)
  remount-write     75 -> 1090 MiB/s  (+14x)
  remount-read      4.9 -> 8.8 MiB/s  (+80%)

Durability verified with SizeSweepExtended (1-60 MiB writes through
close+remount+read) and the multi-cluster benchRemountRead (1 MiB
roundtrip). All JFAT unit tests pass.

Author: LSantha

fs/src/fs/org/jnode/fs/jfat/FatChain.java

@@ -434,37 +434,33 @@ public void write(long length, long offset, ByteBuffer src) throws IOException {
          * i.next(); else break;
          */
 
-        try {
-            if (last != clidx) {
-                int m = clidx - last;
+        if (last != clidx) {
+            int m = clidx - last;
 
-                long lst = offset + src.remaining() - last * clsize;
+            long lst = offset + src.remaining() - last * clsize;
 
-                int n = (int) (lst / clsize);
-                if ((lst % clsize) != 0)
-                    n++;
+            int n = (int) (lst / clsize);
+            if ((lst % clsize) != 0)
+                n++;
 
-                last = allocateTail(n, m, p.getOffset());
+            last = allocateTail(n, m, p.getOffset());
 
-                if (cluster != 0) {
-                    fat.set(cluster, last);
-                    ((ChainIterator) i).appendChain(last);
-                } else {
-                    setStartCluster(last);
-                    // i = listIterator ( clidx );
-                }
+            if (cluster != 0) {
+                fat.set(cluster, last);
+                ((ChainIterator) i).appendChain(last);
+            } else {
+                setStartCluster(last);
+                // i = listIterator ( clidx );
+            }
 
-                /*
-                 * here length is used to decide if we have to zero the data
-                 * inside the last cluster tail
-                 */
-                int ofs = (int) (length % clsize);
+            /*
+             * here length is used to decide if we have to zero the data
+             * inside the last cluster tail
+             */
+            int ofs = (int) (length % clsize);
 
-                if (ofs != 0)
-                    fat.clearCluster(cluster, ofs, clsize);
-            }
-        } finally {
-            fat.flush();
+            if (ofs != 0)
+                fat.clearCluster(cluster, ofs, clsize);
         }
 
         for (int l = src.remaining(), sz = p.getPartial(), ofs = p.getOffset(), size; l > 0; l -=
@@ -475,18 +471,14 @@ public void write(long length, long offset, ByteBuffer src) throws IOException {
                 if ((l % clsize) != 0)
                     n++;
 
-                try {
-                    last = allocateTail(n);
-
-                    if (cluster != 0) {
-                        fat.set(cluster, last);
-                        ((ChainIterator) i).appendChain(last);
-                    } else {
-                        setStartCluster(last);
-                        // i = listIterator ( 0 );
-                    }
-                } finally {
-                    fat.flush();
+                last = allocateTail(n);
+
+                if (cluster != 0) {
+                    fat.set(cluster, last);
+                    ((ChainIterator) i).appendChain(last);
+                } else {
+                    setStartCluster(last);
+                    // i = listIterator ( 0 );
                 }
             }
 

fs/src/fs/org/jnode/fs/jfat/FatFile.java

@@ -112,7 +112,13 @@ public void write(long offset, ByteBuffer src) throws IOException {
 
         if (lst != offset) setLastModified(System.currentTimeMillis());
 
-        flush();
+        // The dirty FAT cache, dir entry, and chain are flushed lazily by an
+        // explicit file.flush() / fs.flush() / fs.close(). Flushing on every
+        // write forced an O(N) scan of every dirty cache element per write,
+        // killing throughput for sequential / append-heavy workloads.
+        // Durability is preserved because AbstractFileSystem.close() always
+        // calls flush() in the non-readOnly case, and FatFileSystem.flush()
+        // routes through flushFiles() + fat.flush().
     }
 
     @Override