github.com/filecoin-project/specs-actors/v4@v4.0.2/actors/states/tree_test.go (about)

     1  package states_test
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"testing"
     7  
     8  	address "github.com/filecoin-project/go-address"
     9  	"github.com/filecoin-project/go-state-types/big"
    10  	"github.com/ipfs/go-cid"
    11  	"github.com/stretchr/testify/require"
    12  
    13  	"github.com/filecoin-project/specs-actors/v4/actors/builtin"
    14  	"github.com/filecoin-project/specs-actors/v4/actors/states"
    15  	"github.com/filecoin-project/specs-actors/v4/support/ipld"
    16  )
    17  
    18  func BenchmarkStateTreeSet(b *testing.B) {
    19  	store := ipld.NewADTStore(context.Background())
    20  	st, err := states.NewTree(store)
    21  	require.NoError(b, err)
    22  
    23  	b.ResetTimer()
    24  	b.ReportAllocs()
    25  
    26  	for i := 0; i < b.N; i++ {
    27  		a, err := address.NewIDAddress(uint64(i))
    28  		if err != nil {
    29  			b.Fatal(err)
    30  		}
    31  		err = st.SetActor(a, &states.Actor{
    32  			Code:       builtin.StorageMinerActorCodeID,
    33  			Head:       builtin.AccountActorCodeID,
    34  			CallSeqNum: uint64(i),
    35  			Balance:    big.NewInt(1258812523),
    36  		})
    37  		if err != nil {
    38  			b.Fatal(err)
    39  		}
    40  	}
    41  }
    42  
    43  func BenchmarkStateTreeSetFlush(b *testing.B) {
    44  	store := ipld.NewADTStore(context.Background())
    45  	st, err := states.NewTree(store)
    46  	require.NoError(b, err)
    47  
    48  	b.ResetTimer()
    49  	b.ReportAllocs()
    50  
    51  	for i := 0; i < b.N; i++ {
    52  		a, err := address.NewIDAddress(uint64(i))
    53  		if err != nil {
    54  			b.Fatal(err)
    55  		}
    56  
    57  		err = st.SetActor(a, &states.Actor{
    58  			Code:       builtin.StorageMinerActorCodeID,
    59  			Head:       builtin.AccountActorCodeID,
    60  			CallSeqNum: uint64(i),
    61  			Balance:    big.NewInt(1258812523),
    62  		})
    63  		if err != nil {
    64  			b.Fatal(err)
    65  		}
    66  
    67  		_, err = st.Flush()
    68  		if err != nil {
    69  			b.Fatal(err)
    70  		}
    71  	}
    72  }
    73  
    74  func BenchmarkStateTree10kGetActor(b *testing.B) {
    75  	store := ipld.NewADTStore(context.Background())
    76  	st, err := states.NewTree(store)
    77  	require.NoError(b, err)
    78  
    79  	for i := 0; i < 10000; i++ {
    80  		a, err := address.NewIDAddress(uint64(i))
    81  		if err != nil {
    82  			b.Fatal(err)
    83  		}
    84  
    85  		err = st.SetActor(a, &states.Actor{
    86  			Code:       builtin.StorageMinerActorCodeID,
    87  			Head:       builtin.AccountActorCodeID,
    88  			CallSeqNum: uint64(i),
    89  			Balance:    big.NewIntUnsigned(1258812523 + uint64(i)),
    90  		})
    91  		if err != nil {
    92  			b.Fatal(err)
    93  		}
    94  	}
    95  
    96  	_, err = st.Flush()
    97  	require.NoError(b, err)
    98  
    99  	b.ResetTimer()
   100  	b.ReportAllocs()
   101  
   102  	for i := 0; i < b.N; i++ {
   103  		a, err := address.NewIDAddress(uint64(i % 10000))
   104  		if err != nil {
   105  			b.Fatal(err)
   106  		}
   107  
   108  		_, found, err := st.GetActor(a)
   109  		if !found {
   110  			b.Fatal(err)
   111  		}
   112  		if err != nil {
   113  			b.Fatal(err)
   114  		}
   115  	}
   116  }
   117  
   118  func TestSetCache(t *testing.T) {
   119  	store := ipld.NewADTStore(context.Background())
   120  	st, err := states.NewTree(store)
   121  	require.NoError(t, err)
   122  
   123  	a, err := address.NewIDAddress(uint64(222))
   124  	if err != nil {
   125  		t.Fatal(err)
   126  	}
   127  
   128  	act := &states.Actor{
   129  		Code:       builtin.StorageMinerActorCodeID,
   130  		Head:       builtin.AccountActorCodeID,
   131  		CallSeqNum: 0,
   132  		Balance:    big.NewInt(0),
   133  	}
   134  
   135  	err = st.SetActor(a, act)
   136  	require.NoError(t, err)
   137  
   138  	act.CallSeqNum = 1
   139  
   140  	outact, found, err := st.GetActor(a)
   141  	require.True(t, found)
   142  	require.NoError(t, err)
   143  
   144  	if outact.CallSeqNum == 1 {
   145  		t.Error("nonce should not have updated")
   146  	}
   147  }
   148  
   149  func TestStateTreeConsistency(t *testing.T) {
   150  	store := ipld.NewADTStore(context.Background())
   151  	st, err := states.NewTree(store)
   152  	require.NoError(t, err)
   153  
   154  	var addrs []address.Address
   155  	for i := 100; i < 150; i++ {
   156  		a, err := address.NewIDAddress(uint64(i))
   157  		require.NoError(t, err)
   158  		addrs = append(addrs, a)
   159  	}
   160  
   161  	randomCid, err := cid.Decode("bafy2bzacecu7n7wbtogznrtuuvf73dsz7wasgyneqasksdblxupnyovmtwxxu")
   162  	require.NoError(t, err)
   163  
   164  	for i, a := range addrs {
   165  		err := st.SetActor(a, &states.Actor{
   166  			Code:       randomCid,
   167  			Head:       randomCid,
   168  			CallSeqNum: uint64(1000 - i),
   169  			Balance:    big.NewInt(int64(10000 + i)),
   170  		})
   171  		require.NoError(t, err)
   172  	}
   173  
   174  	root, err := st.Flush()
   175  	require.NoError(t, err)
   176  
   177  	fmt.Println("root is: ", root)
   178  	if root.String() != "bafy2bzacea3yrl2k3dyaifdkpign5muvfjavxntzt2mwl6golpwlz5sa4mpy2" {
   179  		t.Fatal("MISMATCH!")
   180  	}
   181  }