s/epoch/serial/ s/flush/commit/

README.md

···
 
 The writer does synchronize any actions with a central mutex lock.  Keys and
 values are kept at most three times:  Once for both arenas, plus any
-non-flushed value in the operations log.  The writer is in control over how
-long that operations log is:  It is truncated after each flush operation.  The
-delay of each flush is dependent on the readers:  They need to preemptively
-leave the arena to allow the writer to carry out the flush operation.
+non-commited value in the operations log.  The writer is in control over how
+long that operations log is:  It is truncated after each commit operation.  The
+delay of each commit is dependent on the readers:  They need to preemptively
+leave the arena to allow the writer to carry out the commit operation.
 
 The "sign", which is in fact a simple pointer, is written by the writer and
 read by the readers with atomic operations.  The signaling of where the readers
-are is done with an unsigned integer counter (named "epoch") that is atomically
+are is done with an unsigned integer counter (named "serial") that is atomically
 incremented by 1 when entering an arena and when leaving an arena.  Thus, if a
-reader has entered an arena the epoch is odd, and even if the reader has left
-the arenas.  The writer atomically reads each epoch and spins over every epoch
-that happened to be odd at that first read until all of those epochs differ
-from the recorded odd epoch.   That ensures that every reader has at least once
+reader has entered an arena the serial is odd, and even if the reader has left
+the arenas.  The writer atomically reads each serial and spins over every serial
+that happened to be odd at that first read until all of those serials differ
+from the recorded odd serial.   That ensures that every reader has at least once
 read the pointer after the writer swapped it (and also handles the case of
-overflowed epochs).
+overflowed serials).
 
 ### Performance
 

lrmap.go

···
 	readers := make(map[*readHandlerInner[K, V]]uint64)
 
 	for rh := range m.readHandlers {
-		if epoch := atomic.LoadUint64(&(rh.epoch)); epoch%2 == 1 {
-			readers[rh] = epoch
+		if serial := atomic.LoadUint64(&(rh.serial)); serial%2 == 1 {
+			readers[rh] = serial
 		}
 	}
 
 	delay := time.Microsecond
 
 	for {
-		for reader, epoch := range readers {
-			if e := atomic.LoadUint64(&(reader.epoch)); e != epoch {
+		for reader, serial := range readers {
+			if s := atomic.LoadUint64(&(reader.serial)); s != serial {
 				delete(readers, reader)
 			}
 		}
···
 }
 
 type readHandlerInner[K comparable, V any] struct {
-	lrmap *LRMap[K, V]
-	live  arena[K, V]
-	epoch uint64
+	lrmap  *LRMap[K, V]
+	live   arena[K, V]
+	serial uint64
 }
 
 func (r *readHandlerInner[K, V]) enter() {
···
 		panic("reader illegal state: must not Enter() twice")
 	}
 
-	atomic.AddUint64(&r.epoch, 1)
+	atomic.AddUint64(&r.serial, 1)
 	r.live = *r.lrmap.readMap.Load()
 }
 
···
 		panic("reader illegal state: must not Leave() twice")
 	}
 
-	atomic.AddUint64(&r.epoch, 1)
+	atomic.AddUint64(&r.serial, 1)
 }
 
 func (r *readHandlerInner[K, V]) get(key K) V {
···
 }
 
 func (r *readHandlerInner[K, V]) entered() bool {
-	return r.epoch%2 == 1
+	return r.serial%2 == 1
 }

lrmap_test.go

···
 	rh.Leave()
 }
 
-func TestEpochOverflow(t *testing.T) {
+func TestSerialOverflow(t *testing.T) {
 	var maxEven uint64 = math.MaxUint64 - 1
 	t.Logf("maxEven(%d)", maxEven)
 	if maxEven%2 == 1 {