fix timing errors and other weirdness

Author: mafintosh

bench.js

@@ -1,7 +1,36 @@
 const createFile = require('./')
 
 const st = createFile('benchmark.txt')
-st.open(benchWrite)
+st.open(tinyWrites)
+
+function tinyWrites () {
+  var offset = 0
+  const buf = Buffer.alloc(1)
+  console.time('10000 tiny writes')
+  st.write(0, buf, function onwrite (err) {
+    if (err) throw err
+    offset++
+    if (offset === 10000) {
+      console.timeEnd('10000 tiny writes')
+      return tinyReads()
+    }
+    st.write(offset, buf, onwrite)
+  })
+}
+
+function tinyReads () {
+  var offset = 0
+  console.time('10000 tiny reads')
+  st.read(0, 1, function onread (err) {
+    if (err) throw err
+    offset++
+    if (offset === 10000) {
+      console.timeEnd('10000 tiny reads')
+      return benchWrite()
+    }
+    st.read(offset, 1, onread)
+  })
+}
 
 function benchRead () {
   var offset = 0

index.js

@@ -25,118 +25,31 @@ function createFile (name, opts) {
   if (!opts) opts = {}
 
   const maxSize = opts.maxSize || createFile.DEFAULT_MAX_SIZE
-  const waiting = []
-  const writers = []
-  const readers = []
+  const mutex = new Mutex()
 
   var fs = null
   var file = null
   var entry = null
-  var truncate = null
-  var totalWriters = 0
+  var readers = []
+  var writers = []
 
   return ras({read, write, open, stat, close})
 
-  function wait (req) {
-    waiting.push(req)
-  }
-
-  function allocWriter (req) {
-    const io = {writer: null, req: null}
-
-    entry.createWriter(function (writer) {
-      io.writer = writer
-      io.writer.onerror = function (err) {
-        onwrite(err)
-      }
-      io.writer.onwriteend = function () {
-        onwrite(null)
-      }
-
-      writers.push(io)
-      totalWriters++
-      write(req)
-    }, onallocerror)
-
-    function onallocerror (err) {
-      req.callback(err)
-    }
-
-    function onwrite (err) {
-      const req = io.req
-      io.req = null
-      writers.push(io)
-
-      if (truncate) {
-        if (io === truncate) {
-          truncate = null
-          while (waiting.length) write(waiting.pop())
-          write(req)
-          return
-        }
-
-        if (totalWriters - writers.length === 1) {
-          truncate.writer.truncate(truncate.req.offset)
-        }
-      }
-
-      req.callback(err, null)
-    }
-  }
-
-  function allocReader () {
-    const io = {reader: null, req: null}
-
-    io.reader = new FileReader()
-    io.reader.onerror = function (err) {
-      onread(err, null)
-    }
-    io.reader.onload = function () {
-      onread(null, Buffer.from(this.result))
-    }
-
-    return io
-
-    function onread (err, buf) {
-      const req = io.req
-      io.req = null
-      readers.push(io)
-      req.callback(err, buf)
-    }
-  }
-
   function read (req) {
-    const end = req.offset + req.size
-    if (end > file.size) return req.callback(new Error('Could not satisfy length'))
+    const r = readers.pop() || new ReadRequest(readers, file, entry, mutex)
+    r.run(req)
+  }
 
-    const io = readers.pop() || allocReader()
-    io.req = req
-    io.reader.readAsArrayBuffer(file.slice(req.offset, end))
+  function write (req) {
+    const w = writers.pop() || new WriteRequest(writers, file, entry, mutex)
+    w.run(req)
   }
 
   function close (req) {
-    entry = file = fs = null
+    readers = writers = entry = file = fs = null
     req.callback(null)
   }
 
-  function write (req) {
-    if (truncate) return wait(req)
-
-    const io = writers.pop()
-    if (!io) return allocWriter(req)
-
-    io.req = req
-
-    if (req.offset > file.size) {
-      truncate = io
-      if (totalWriters - writers.length === 1) io.writer.truncate(req.offset)
-      return
-    }
-
-    io.writer.seek(req.offset)
-    io.writer.write(new Blob([req.data], TYPE))
-  }
-
   function stat (req) {
     req.callback(null, file)
   }
@@ -162,3 +75,156 @@ function createFile (name, opts) {
     }
   }
 }
+
+function WriteRequest (pool, file, entry, mutex) {
+  this.writer = null
+  this.entry = entry
+  this.file = file
+  this.req = null
+  this.pool = pool
+  this.mutex = mutex
+  this.locked = false
+  this.truncating = false
+}
+
+WriteRequest.prototype.makeWriter = function () {
+  const self = this
+  this.entry.createWriter(function (writer) {
+    self.writer = writer
+
+    writer.onwriteend = function () {
+      if (self.writer !== writer) throw new Error('nah')
+      self.onwrite(null)
+    }
+
+    writer.onerror = function (err) {
+      if (self.writer !== writer) throw new Error('nah')
+      console.log('ONERROR', arguments)
+      self.onwrite(err)
+    }
+
+    self.run(self.req)
+  })
+}
+
+WriteRequest.prototype.onwrite = function (err) {
+  const req = this.req
+  this.req = null
+
+  if (this.locked) {
+    this.locked = false
+    this.mutex.release()
+  }
+
+  if (this.truncating) {
+    this.truncating = false
+    if (!err) return this.run(req)
+  }
+
+  this.pool.push(this)
+  if (err) console.log('ERROR HERE', err)
+  req.callback(err, null)
+}
+
+WriteRequest.prototype.truncate = function () {
+  this.truncating = true
+  this.writer.truncate(this.req.offset)
+}
+
+WriteRequest.prototype.lock = function () {
+  if (this.locked) return true
+  this.locked = this.mutex.lock(this)
+  return this.locked
+}
+
+WriteRequest.prototype.run = function (req) {
+  this.req = req
+  if (!this.writer || this.writer.length !== this.file.size) return this.makeWriter()
+
+  const end = req.offset + req.size
+  if (end > this.file.size && !this.lock()) return
+
+  if (req.offset > this.writer.length) {
+    if (req.offset > this.file.size) return this.truncate()
+    return this.makeWriter()
+  }
+
+  this.writer.seek(req.offset)
+  this.writer.write(new Blob([req.data], TYPE))
+}
+
+function Mutex () {
+  this.queued = null
+}
+
+Mutex.prototype.release = function () {
+  const queued = this.queued
+  this.queued = null
+  for (var i = 0; i < queued.length; i++) {
+    queued[i].run(queued[i].req)
+  }
+}
+
+Mutex.prototype.lock = function (req) {
+  if (this.queued) {
+    this.queued.push(req)
+    return false
+  }
+  this.queued = []
+  return true
+}
+
+function ReadRequest (pool, file, entry, mutex) {
+  this.reader = new FileReader()
+  this.file = file
+  this.req = null
+  this.pool = pool
+  this.retry = true
+  this.mutex = mutex
+  this.locked = false
+
+  const self = this
+
+  this.reader.onerror = function () {
+    self.onread(this.error, null)
+  }
+
+  this.reader.onload = function () {
+    const buf = Buffer.from(this.result)
+    self.onread(null, buf)
+  }
+}
+
+ReadRequest.prototype.lock = function () {
+  if (this.locked) return true
+  this.locked = this.mutex.lock(this)
+  return this.locked
+}
+
+ReadRequest.prototype.onread = function (err, buf) {
+  const req = this.req
+
+  if (err && this.retry) {
+    this.retry = false
+    if (this.lock(this)) this.run(req)
+    return
+  }
+
+  this.req = null
+  this.pool.push(this)
+  this.retry = true
+
+  if (this.locked) {
+    this.locked = false
+    this.mutex.release()
+  }
+
+  req.callback(err, buf)
+}
+
+ReadRequest.prototype.run = function (req) {
+  const end = req.offset + req.size
+  this.req = req
+  if (end > this.file.size) return this.onread(new Error('Could not satisfy length'), null)
+  this.reader.readAsArrayBuffer(this.file.slice(req.offset, end))
+}