fix: reduce memory by avoiding clone in Iter and adapt callers

Author: HayoungOh5

isaac/database/center.go

@@ -777,85 +777,74 @@ func (db *Center) cleanRemoved(limit int) error {
 
 func loadTemp(
 	st *leveldbstorage.Storage,
-	height base.Height,
+	h base.Height,
 	encs *encoder.Encoders,
 	enc encoder.Encoder,
 ) (isaac.TempDatabase, error) {
+
 	r := &leveldbutil.Range{
-		Start: emptyPrefixStoragePrefixByHeight(leveldbLabelBlockWrite, height),   //nolint:gomnd //...
-		Limit: emptyPrefixStoragePrefixByHeight(leveldbLabelBlockWrite, height+1), //nolint:gomnd //...
+		Start: emptyPrefixStoragePrefixByHeight(leveldbLabelBlockWrite, h),
+		Limit: emptyPrefixStoragePrefixByHeight(leveldbLabelBlockWrite, h+1),
+	}
+
+	const delBufCap = 128
+	var delBuf = make([][]byte, 0, delBufCap)
+
+	flushDeletes := func() error {
+		if len(delBuf) == 0 {
+			return nil
+		}
+		for _, p := range delBuf {
+			if err := leveldbstorage.RemoveByPrefix(st, p); err != nil {
+				return err
+			}
+		}
+		delBuf = delBuf[:0]
+		return nil
 	}
 
-	var lastprefix []byte
-	var prefixes [][]byte
+	var lastPrefix []byte
+	var found isaac.TempDatabase
 
 	if err := st.Iter(
 		r,
-		func(key, _ []byte) (bool, error) {
-			k, err := prefixStoragePrefixFromKey(key)
-			if err != nil {
+		func(k, _ []byte) (bool, error) {
+			prefix, err := prefixStoragePrefixFromKey(k)
+			if err != nil || bytes.Equal(prefix, lastPrefix) {
 				return true, nil
 			}
+			lastPrefix = prefix
 
-			if bytes.Equal(k, lastprefix) {
+			if found != nil {
+				delBuf = append(delBuf, prefix)
+				if len(delBuf) >= delBufCap {
+					return false, flushDeletes()
+				}
 				return true, nil
 			}
 
-			lastprefix = k
+			temp, err := NewTempLeveldbFromPrefix(st, prefix, encs, enc)
+			if err != nil {
+				delBuf = append(delBuf, prefix)
+				return true, nil
+			}
 
-			prefixes = append(prefixes, k)
+			isMerged, err := temp.isMerged()
+			if err != nil || !isMerged {
+				delBuf = append(delBuf, prefix)
+				return true, nil
+			}
 
+			found = temp
 			return true, nil
 		},
 		false,
 	); err != nil {
 		return nil, err
 	}
 
-	if len(prefixes) < 1 {
-		return nil, nil
-	}
-
-	var useless [][]byte
-
-	var found isaac.TempDatabase
-
-	for i := range prefixes {
-		prefix := prefixes[i]
-
-		if found != nil {
-			useless = append(useless, prefix)
-
-			continue
-		}
-
-		temp, err := NewTempLeveldbFromPrefix(st, prefix, encs, enc)
-		if err != nil {
-			useless = append(useless, prefix)
-
-			continue
-		}
-
-		switch ismerged, err := temp.isMerged(); {
-		case err != nil:
-			useless = append(useless, prefix)
-
-			continue
-		case !ismerged:
-			useless = append(useless, prefix)
-
-			continue
-		default:
-			found = temp
-		}
-	}
-
-	if len(useless) > 0 {
-		for i := range useless {
-			if err := leveldbstorage.RemoveByPrefix(st, useless[i]); err != nil {
-				return nil, err
-			}
-		}
+	if err := flushDeletes(); err != nil {
+		return nil, err
 	}
 
 	return found, nil

isaac/database/pool.go

@@ -982,74 +982,90 @@ func (db *TempPool) cleanByHeight(
 	deep int,
 	keyf func(*leveldbstorage.PrefixStorageBatch, []byte, []byte),
 ) (int, error) {
+
 	pst, err := db.st()
 	if err != nil {
 		return 0, err
 	}
 
-	top := base.NilHeight
-
-	var keys [][3]interface{}
-
-	_ = pst.Iter(
+	var top base.Height
+	err = pst.Iter(
 		leveldbutil.BytesPrefix(prefix[:]),
-		func(key, b []byte) (bool, error) {
-			i, err := heightFromKey(key, prefix)
-			if err != nil {
-				keys = append(keys, [3]interface{}{key, b, nil})
-
-				return true, nil
-			}
-
-			if i > top {
-				top = i
+		func(k, _ []byte) (bool, error) {
+			h, e := heightFromKey(k, prefix)
+			if e != nil {
+				return false, e
 			}
-
-			keys = append(keys, [3]interface{}{key, b, i})
-
-			return true, nil
+			top = h
+			return false, nil
 		},
 		false,
 	)
-
-	height := top
-
-	switch {
-	case len(keys) < 1:
-		return 0, nil
-	case top-3 < base.GenesisHeight:
+	if err != nil {
+		return 0, err
+	}
+	if top == base.NilHeight {
 		return 0, nil
-	default:
-		for range make([]int, deep) {
-			height = height.SafePrev()
+	}
+
+	cutoff := top
+	for i := 0; i < deep; i++ {
+		cutoff = cutoff.SafePrev()
+		if cutoff < base.GenesisHeight {
+			return 0, nil
 		}
 	}
 
+	const recLimit = 10_000   // Record count threshold (tunable)
+	const byteLimit = 4 << 20 // 4MiB threshold (tunable)
+
 	batch := pst.NewBatch()
 	defer batch.Reset()
 
-	var removed int
+	var removed, recCnt, byteCnt int
 
-	for i := range keys {
-		key, b, j := keys[i][0].([]byte), keys[i][1].([]byte), keys[i][2] //nolint:forcetypeassert //...
-		if j != nil && j.(base.Height) > height {                         //nolint:forcetypeassert //...
-			continue
-		}
+	err = pst.Iter(
+		leveldbutil.BytesPrefix(prefix[:]),
+		func(k, v []byte) (bool, error) {
 
-		batch.Delete(key)
+			h, e := heightFromKey(k, prefix)
+			if e != nil || h > cutoff {
+				return true, e
+			}
 
-		if keyf != nil {
-			keyf(batch, key, b)
-		}
+			batch.Delete(k)
+
+			if keyf != nil {
+				keyf(batch, k, v)
+			}
+
+			recCnt++
+			byteCnt += len(k) + len(v)
 
-		removed++
+			if recCnt >= recLimit || byteCnt >= byteLimit {
+				if err := pst.Batch(batch, nil); err != nil {
+					return false, err
+				}
+				removed += recCnt
+				batch.Reset()
+				recCnt, byteCnt = 0, 0
+			}
+			return true, nil
+		},
+		true,
+	)
+	if err != nil {
+		return removed, err
 	}
 
-	if batch.Len() < 1 {
-		return removed, nil
+	if recCnt > 0 {
+		if err := pst.Batch(batch, nil); err != nil {
+			return removed, err
+		}
+		removed += recCnt
 	}
 
-	return removed, pst.Batch(batch, nil)
+	return removed, nil
 }
 
 func (db *TempPool) opFromCache(h util.Hash) (base.Operation, bool) {

storage/leveldb/db.go

@@ -1,7 +1,6 @@
 package leveldbstorage
 
 import (
-	"bytes"
 	"context"
 	"sync"
 
@@ -106,47 +105,32 @@ func (st *Storage) Exists(key []byte) (bool, error) {
 
 func (st *Storage) Iter(
 	r *leveldbutil.Range,
-	callback func(key []byte, raw []byte) (bool, error),
-	sort bool, // NOTE if true, ascend order
+	callback func(key, val []byte) (bool, error),
+	ascend bool,
 ) error {
 	db, err := st.db()
 	if err != nil {
 		return err
 	}
-
 	iter := db.NewIterator(r, nil)
 	defer iter.Release()
 
-	var seek func() bool
-	var next func() bool
-	if sort {
-		seek = iter.First
-		next = iter.Next
-	} else {
-		seek = iter.Last
-		next = iter.Prev
-	}
-
-	if !seek() {
-		return nil
+	seek, next := iter.Last, iter.Prev
+	if ascend {
+		seek, next = iter.First, iter.Next
 	}
-
-end:
-	for {
-		switch keep, err := callback(bytes.Clone(iter.Key()), bytes.Clone(iter.Value())); {
-		case err != nil:
+	for ok := seek(); ok; ok = next() {
+		keep, err := callback(iter.Key(), iter.Value())
+		if err != nil {
 			return err
-		case !keep:
-			break end
-		case !next():
-			break end
+		}
+		if !keep {
+			break
 		}
 	}
-
 	if err := iter.Error(); err != nil {
 		return storage.ErrExec.Errorf("iter")
 	}
-
 	return nil
 }
 
@@ -315,51 +299,51 @@ func BatchRemove(st *Storage, r *leveldbutil.Range, limit int) (int, error) {
 		return 0, err
 	}
 
-	var removed int
-
-	var batch leveldb.Batch
+	var (
+		removed int
+		batch   leveldb.Batch
+	)
 	defer batch.Reset()
 
 	if r == nil {
 		r = &leveldbutil.Range{}
 	}
-
 	start := r.Start
 
 	for {
 		r.Start = start
+		var nextStart []byte
 
 		if err := st.Iter(
 			r,
 			func(key, _ []byte) (bool, error) {
 				if batch.Len() == limit {
-					start = key
-
+					// Copy the key only for one moment when the limit is reached
+					nextStart = append(nextStart[:0], key...)
 					return false, nil
 				}
-
 				batch.Delete(key)
-
 				return true, nil
 			},
 			true,
 		); err != nil {
 			return removed, err
 		}
 
-		if batch.Len() < 1 {
+		if batch.Len() == 0 {
 			break
 		}
-
 		if err := st.Batch(&batch, nil); err != nil {
 			return removed, err
 		}
-
 		removed += batch.Len()
-
 		batch.Reset()
-	}
 
+		if nextStart == nil {
+			break
+		}
+		start = nextStart
+	}
 	return removed, nil
 }