storagenode/hashstore: remove monkit from hashtbl

the benchmarks speak for themselves.

name             old time/op    new time/op    delta
Compact/lrec=17  767ms ± 4%     349ms ± 2%   -54.54%
Compact/lrec=18  1.47s ± 2%     0.63s ± 8%   -57.21%
Compact/lrec=19  2.84s ± 3%     1.18s ± 3%   -58.48%
Compact/lrec=20  5.58s ± 3%     2.12s ± 3%   -62.04%
Compact/lrec=21  11.1s ± 1%      4.1s ±12%   -62.94%
Compact/lrec=22  21.8s ± 1%      7.7s ± 3%   -64.74%
Compact/lrec=23  44.0s ± 2%     15.1s ± 3%   -65.67%

name            old alloc/op   new alloc/op    delta
Compact/lrec=17 36.7MB ± 0%     1.1MB ± 0%   -97.09%
Compact/lrec=18 72.4MB ± 0%     1.1MB ± 0%   -98.53%
Compact/lrec=19  144MB ± 0%       1MB ± 0%   -99.26%
Compact/lrec=20  286MB ± 0%       1MB ± 0%   -99.63%
Compact/lrec=21  571MB ± 0%       1MB ± 0%   -99.81%
Compact/lrec=22 1.14GB ± 0%    0.00GB ± 0%   -99.91%
Compact/lrec=23 2.28GB ± 0%    0.00GB ± 0%   -99.95%

name             old allocs/op  new allocs/op  delta
Compact/lrec=17   655k ± 0%        0k ± 2%   -99.99%
Compact/lrec=18  1.31M ± 0%     0.00M ± 2%   -99.99%
Compact/lrec=19  2.62M ± 0%     0.00M ± 3%  -100.00%
Compact/lrec=20  5.24M ± 0%     0.00M ± 7%  -100.00%
Compact/lrec=21  10.5M ± 0%      0.0M ± 3%  -100.00%
Compact/lrec=22  21.0M ± 0%      0.0M ± 4%  -100.00%
Compact/lrec=23  41.9M ± 0%      0.0M ± 3%  -100.00%

name              old rec/sec    new rec/sec   delta
Compact/lrec=17   171k ± 4%      376k ± 2%  +119.93%
Compact/lrec=18   178k ± 2%      416k ± 8%  +134.00%
Compact/lrec=19   184k ± 3%      444k ± 3%  +140.86%
Compact/lrec=20   188k ± 3%      495k ± 2%  +163.41%
Compact/lrec=21   189k ± 1%      512k ±11%  +171.06%
Compact/lrec=22   193k ± 1%      547k ± 3%  +183.69%
Compact/lrec=23   191k ± 2%      555k ± 3%  +191.26%

Change-Id: Ib3f895ee15fd36c5e55fbe7f54d03b39a6649f5b

Author: zeebo

storagenode/hashstore/hashtbl.go

@@ -317,12 +317,8 @@ func (h *HashTbl) Load() float64 {
 	return float64(h.numSet) / float64(h.numSlots)
 }
 
-var rangeTask = mon.Task()
-
 // Range iterates over the records in hash table order.
 func (h *HashTbl) Range(fn func(Record, error) bool) {
-	defer rangeTask(nil)(nil)
-
 	h.opMu.RLock()
 	defer h.opMu.RUnlock()
 
@@ -387,14 +383,10 @@ func (h *HashTbl) ExpectOrdered() (flush func() error, done func(), err error) {
 		}, nil
 }
 
-var insertTask = mon.Task()
-
 // Insert adds a record to the hash table. It returns (true, nil) if the record was inserted, it
 // returns (false, nil) if the hash table is full, and (false, err) if any errors happened trying
 // to insert the record.
 func (h *HashTbl) Insert(rec Record) (_ bool, err error) {
-	defer insertTask(nil)(&err)
-
 	h.opMu.Lock()
 	defer h.opMu.Unlock()
 
@@ -485,14 +477,10 @@ func (h *HashTbl) Insert(rec Record) (_ bool, err error) {
 	return false, nil
 }
 
-var lookupTask = mon.Task()
-
 // Lookup returns the record for the given key if it exists in the hash table. It returns (rec,
 // true, nil) if the record existed, (rec{}, false, nil) if it did not exist, and (rec{}, false,
 // err) if any errors happened trying to look up the record.
 func (h *HashTbl) Lookup(key Key) (_ Record, _ bool, err error) {
-	defer lookupTask(nil)(&err)
-
 	h.opMu.RLock()
 	defer h.opMu.RUnlock()
 

storagenode/hashstore/log.go

@@ -306,7 +306,7 @@ func (h *Writer) Close() (err error) {
 
 	// if we are not in manual mode, then we need to add the record.
 	if !h.manual {
-		if err := h.store.addRecord(ctx, h.rec); err != nil {
+		if err := h.store.addRecord(h.rec); err != nil {
 			// if we can't add the record, we should abort the write operation and attempt to
 			// reclaim space by seeking backwards to the record offset.
 			_, _ = h.lf.fh.Seek(int64(size), io.SeekStart)

storagenode/hashstore/store.go

@@ -331,13 +331,7 @@ func (s *Store) acquireLogFile(ttl uint32) (*logFile, error) {
 	return lf, err
 }
 
-func (s *Store) addRecord(ctx context.Context, rec Record) error {
-	// sometimes a Writer is created with a nil store so that it can disable automatically writing
-	// records.
-	if s == nil {
-		return nil
-	}
-
+func (s *Store) addRecord(rec Record) error {
 	ok, err := s.tbl.Insert(rec)
 	if err != nil {
 		return Error.Wrap(err)
@@ -539,7 +533,7 @@ func (s *Store) reviveRecord(ctx context.Context, lf *logFile, rec Record) (err
 		}
 
 		tmp.Expires = 0
-		return s.addRecord(ctx, tmp)
+		return s.addRecord(tmp)
 	}
 
 	// 4. otherwise, we either had an error looking up the current record, or the entry got fully

storagenode/hashstore/store_test.go

@@ -1043,7 +1043,9 @@ func BenchmarkStore(b *testing.B) {
 		defer s.Close()
 
 		for i := uint64(0); i < 1<<lrec; i++ {
-			s.AssertCreate()
+			wr, err := s.Create(context.Background(), newKey(), time.Time{})
+			assert.NoError(b, err)
+			assert.NoError(b, wr.Close())
 			if s.Load() > 0.5 {
 				s.AssertCompact(nil, time.Time{})
 			}
@@ -1065,5 +1067,4 @@ func BenchmarkStore(b *testing.B) {
 
 		b.ReportMetric(float64(b.N*int(1)<<lrec)/time.Since(now).Seconds(), "rec/sec")
 	})
-
 }