remove fastnode system

basic_test.go

@@ -442,14 +442,14 @@ func TestPersistence(t *testing.T) {
 	}
 
 	// Construct some tree and save it
-	t1 := NewMutableTree(db, 0, false, log.NewNopLogger())
+	t1 := NewMutableTree(db, 0, log.NewNopLogger())
 	for key, value := range records {
 		t1.Set([]byte(key), []byte(value))
 	}
 	t1.SaveVersion()
 
 	// Load a tree
-	t2 := NewMutableTree(db, 0, false, log.NewNopLogger())
+	t2 := NewMutableTree(db, 0, log.NewNopLogger())
 	t2.Load()
 	for key, value := range records {
 		t2value, err := t2.Get([]byte(key))
@@ -497,7 +497,7 @@ func TestProof(t *testing.T) {
 
 func TestTreeProof(t *testing.T) {
 	db := dbm.NewMemDB()
-	tree := NewMutableTree(db, 100, false, log.NewNopLogger())
+	tree := NewMutableTree(db, 100, log.NewNopLogger())
 	hash := tree.Hash()
 	assert.Equal(t, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", hex.EncodeToString(hash))
 

benchmarks/bench_test.go

@@ -27,7 +27,7 @@ func randBytes(length int) []byte {
 }
 
 func prepareTree(b *testing.B, db dbm.DB, size, keyLen, dataLen int) (*iavl.MutableTree, [][]byte) {
-	t := iavl.NewMutableTree(db, size, false, log.NewNopLogger())
+	t := iavl.NewMutableTree(db, size, log.NewNopLogger())
 	keys := make([][]byte, size)
 
 	for i := 0; i < size; i++ {

benchmarks/cosmos-exim/main.go

@@ -92,7 +92,7 @@ func runExport(dbPath string) (int64, map[string][]*iavl.ExportNode, error) {
 	if err != nil {
 		return 0, nil, err
 	}
-	tree := iavl.NewMutableTree(idbm.NewPrefixDB(ldb, []byte("s/k:main/")), 0, false, log.NewNopLogger())
+	tree := iavl.NewMutableTree(idbm.NewPrefixDB(ldb, []byte("s/k:main/")), 0, log.NewNopLogger())
 	version, err := tree.LoadVersion(0)
 	if err != nil {
 		return 0, nil, err
@@ -104,7 +104,7 @@ func runExport(dbPath string) (int64, map[string][]*iavl.ExportNode, error) {
 	totalStats := Stats{}
 	for _, name := range stores {
 		db := idbm.NewPrefixDB(ldb, []byte("s/k:"+name+"/"))
-		tree := iavl.NewMutableTree(db, 0, false, log.NewNopLogger())
+		tree := iavl.NewMutableTree(db, 0, log.NewNopLogger())
 
 		stats := Stats{}
 		export := make([]*iavl.ExportNode, 0, 100000)
@@ -169,7 +169,7 @@ func runImport(version int64, exports map[string][]*iavl.ExportNode) error {
 		if err != nil {
 			return err
 		}
-		newTree := iavl.NewMutableTree(newDB, 0, false, log.NewNopLogger())
+		newTree := iavl.NewMutableTree(newDB, 0, log.NewNopLogger())
 		importer, err := newTree.Import(version)
 		if err != nil {
 			return err

cmd/iaviewer/main.go

@@ -122,7 +122,7 @@ func ReadTree(dir string, version int, prefix []byte) (*iavl.MutableTree, error)
 		db = dbm.NewPrefixDB(db, prefix)
 	}
 
-	tree := iavl.NewMutableTree(newWrapper(db), DefaultCacheSize, false, log.NewLogger(os.Stdout))
+	tree := iavl.NewMutableTree(newWrapper(db), DefaultCacheSize, log.NewLogger(os.Stdout))
 	ver, err := tree.LoadVersion(int64(version))
 	fmt.Printf("Got version: %d\n", ver)
 	return tree, err

diff_test.go

@@ -21,7 +21,7 @@ func TestDiffRoundTrip(t *testing.T) {
 
 	// apply changeSets to tree
 	db := dbm.NewMemDB()
-	tree := NewMutableTree(db, 0, true, log.NewNopLogger())
+	tree := NewMutableTree(db, 0, log.NewNopLogger())
 	for i := range changeSets {
 		v, err := tree.SaveChangeSet(changeSets[i])
 		require.NoError(t, err)
@@ -30,7 +30,7 @@ func TestDiffRoundTrip(t *testing.T) {
 
 	// extract change sets from db
 	var extractChangeSets []*ChangeSet
-	tree2 := NewImmutableTree(db, 0, true, log.NewNopLogger())
+	tree2 := NewImmutableTree(db, 0, log.NewNopLogger())
 	err := tree2.TraverseStateChanges(0, math.MaxInt64, func(_ int64, changeSet *ChangeSet) error {
 		extractChangeSets = append(extractChangeSets, changeSet)
 		return nil

export_test.go

@@ -15,7 +15,7 @@ import (
 // setupExportTreeBasic sets up a basic tree with a handful of
 // create/update/delete operations over a few versions.
 func setupExportTreeBasic(t require.TestingT) *ImmutableTree {
-	tree := NewMutableTree(dbm.NewMemDB(), 0, false, log.NewNopLogger())
+	tree := NewMutableTree(dbm.NewMemDB(), 0, log.NewNopLogger())
 
 	_, err := tree.Set([]byte("x"), []byte{255})
 	require.NoError(t, err)
@@ -74,7 +74,7 @@ func setupExportTreeRandom(t *testing.T) *ImmutableTree {
 	)
 
 	r := rand.New(rand.NewSource(randSeed))
-	tree := NewMutableTree(dbm.NewMemDB(), 0, false, log.NewNopLogger())
+	tree := NewMutableTree(dbm.NewMemDB(), 0, log.NewNopLogger())
 
 	var version int64
 	keys := make([][]byte, 0, versionOps)
@@ -134,7 +134,7 @@ func setupExportTreeSized(t require.TestingT, treeSize int) *ImmutableTree {
 	)
 
 	r := rand.New(rand.NewSource(randSeed))
-	tree := NewMutableTree(dbm.NewMemDB(), 0, false, log.NewNopLogger())
+	tree := NewMutableTree(dbm.NewMemDB(), 0, log.NewNopLogger())
 
 	for i := 0; i < treeSize; i++ {
 		key := make([]byte, keySize)
@@ -228,7 +228,7 @@ func TestExporterCompress(t *testing.T) {
 
 func TestExporter_Import(t *testing.T) {
 	testcases := map[string]*ImmutableTree{
-		"empty tree": NewImmutableTree(dbm.NewMemDB(), 0, false, log.NewNopLogger()),
+		"empty tree": NewImmutableTree(dbm.NewMemDB(), 0, log.NewNopLogger()),
 		"basic tree": setupExportTreeBasic(t),
 	}
 	if !testing.Short() {
@@ -255,7 +255,7 @@ func TestExporter_Import(t *testing.T) {
 					exporter = NewCompressExporter(innerExporter)
 				}
 
-				newTree := NewMutableTree(dbm.NewMemDB(), 0, false, log.NewNopLogger())
+				newTree := NewMutableTree(dbm.NewMemDB(), 0, log.NewNopLogger())
 				innerImporter, err := newTree.Import(tree.Version())
 				require.NoError(t, err)
 				defer innerImporter.Close()
@@ -323,7 +323,7 @@ func TestExporter_Close(t *testing.T) {
 }
 
 func TestExporter_DeleteVersionErrors(t *testing.T) {
-	tree := NewMutableTree(dbm.NewMemDB(), 0, false, log.NewNopLogger())
+	tree := NewMutableTree(dbm.NewMemDB(), 0, log.NewNopLogger())
 
 	_, err := tree.Set([]byte("a"), []byte{1})
 	require.NoError(t, err)

immutable_tree.go

@@ -19,14 +19,13 @@ import (
 type ImmutableTree struct {
 	logger log.Logger
 
-	root                   *Node
-	ndb                    *nodeDB
-	version                int64
-	skipFastStorageUpgrade bool
+	root    *Node
+	ndb     *nodeDB
+	version int64
 }
 
 // NewImmutableTree creates both in-memory and persistent instances
-func NewImmutableTree(db dbm.DB, cacheSize int, skipFastStorageUpgrade bool, lg log.Logger, options ...Option) *ImmutableTree {
+func NewImmutableTree(db dbm.DB, cacheSize int, lg log.Logger, options ...Option) *ImmutableTree {
 	opts := DefaultOptions()
 	for _, opt := range options {
 		opt(&opts)
@@ -40,8 +39,7 @@ func NewImmutableTree(db dbm.DB, cacheSize int, skipFastStorageUpgrade bool, lg
 	return &ImmutableTree{
 		logger: lg,
 		// NodeDB-backed Tree.
-		ndb:                    newNodeDB(db, cacheSize, opts, lg),
-		skipFastStorageUpgrade: skipFastStorageUpgrade,
+		ndb: newNodeDB(db, cacheSize, opts, lg),
 	}
 }
 
@@ -183,32 +181,6 @@ func (t *ImmutableTree) Get(key []byte) ([]byte, error) {
 		return nil, nil
 	}
 
-	if !t.skipFastStorageUpgrade {
-		// attempt to get a FastNode directly from db/cache.
-		// if call fails, fall back to the original IAVL logic in place.
-		fastNode, err := t.ndb.GetFastNode(key)
-		if err != nil {
-			_, result, err := t.root.get(t, key)
-			return result, err
-		}
-
-		if fastNode == nil {
-			// If the tree is of the latest version and fast node is not in the tree
-			// then the regular node is not in the tree either because fast node
-			// represents live state.
-			if t.version == t.ndb.latestVersion {
-				return nil, nil
-			}
-
-			_, result, err := t.root.get(t, key)
-			return result, err
-		}
-
-		if fastNode.GetVersionLastUpdatedAt() <= t.version {
-			return fastNode.GetValue(), nil
-		}
-	}
-
 	// otherwise skipFastStorageUpgrade is true or
 	// the cached node was updated later than the current tree. In this case,
 	// we need to use the regular stategy for reading from the current tree to avoid staleness.
@@ -248,16 +220,6 @@ func (t *ImmutableTree) Iterate(fn func(key []byte, value []byte) bool) (bool, e
 
 // Iterator returns an iterator over the immutable tree.
 func (t *ImmutableTree) Iterator(start, end []byte, ascending bool) (corestore.Iterator, error) {
-	if !t.skipFastStorageUpgrade {
-		isFastCacheEnabled, err := t.IsFastCacheEnabled()
-		if err != nil {
-			return nil, err
-		}
-
-		if isFastCacheEnabled {
-			return NewFastIterator(start, end, ascending, t.ndb), nil
-		}
-	}
 	return NewIterator(start, end, ascending, t), nil
 }
 
@@ -315,10 +277,9 @@ func (t *ImmutableTree) isLatestTreeVersion() (bool, error) {
 // Used internally by MutableTree.
 func (t *ImmutableTree) clone() *ImmutableTree {
 	return &ImmutableTree{
-		root:                   t.root,
-		ndb:                    t.ndb,
-		version:                t.version,
-		skipFastStorageUpgrade: t.skipFastStorageUpgrade,
+		root:    t.root,
+		ndb:     t.ndb,
+		version: t.version,
 	}
 }