prototype: compact blocks #1191
+3,015
−8,987
Next
Next commit
implement prototype for compact blocks
commit bf6edc023364c8d9f227b20f2212d83b041ef93f
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,6 +1,8 @@ | ||
| module github.com/tendermint/tendermint | ||
|
|
||
| go 1.21 | ||
|
|
||
| toolchain go1.21.6 | ||
|
|
||
| require ( | ||
| github.com/BurntSushi/toml v1.2.1 | ||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,263 @@ | ||
| package cat | ||
|
|
||
| import ( | ||
| "context" | ||
| "fmt" | ||
| "sync" | ||
| "time" | ||
|
|
||
| "github.com/tendermint/tendermint/types" | ||
| ) | ||
|
|
||
| // FetchTxsFromKeys is called upon by consensus upon receiving a complete compact block. | ||
| // The method iterates through the keys in the compact block. For the transactions it | ||
| // already has it adds them to a list. For the transactions that are missing it uses a | ||
| // block request to track and retrieve them. Once all transactions are retrieved, it returns | ||
| // the complete set to the consensus engine. This can be called multiple times sequentially | ||
| // with the same blockID and is thread safe | ||
| func (memR *Reactor) FetchTxsFromKeys(ctx context.Context, blockID []byte, compactData [][]byte) ([][]byte, error) { | ||
| if request, ok := memR.blockFetcher.GetRequest(blockID); ok { | ||
| memR.Logger.Debug("tracking existing request for block transactions") | ||
| // we already have a request for this block | ||
| return request.WaitForBlock(ctx) | ||
| } | ||
|
|
||
| txs := make([][]byte, len(compactData)) | ||
| missingKeys := make(map[int]types.TxKey, len(compactData)) | ||
|
|
||
| // iterate through the keys to know what transactions we have and what are missing | ||
| for i, key := range compactData { | ||
| txKey, err := types.TxKeyFromBytes(key) | ||
| if err != nil { | ||
| return nil, fmt.Errorf("incorrect compact blocks format: %w", err) | ||
| } | ||
| wtx := memR.mempool.store.get(txKey) | ||
| if wtx != nil { | ||
| txs[i] = wtx.tx | ||
| } else { | ||
| missingKeys[i] = txKey | ||
| } | ||
| } | ||
| memR.Logger.Info("fetching transactions from peers", "blockID", blockID, "numTxs", len(txs), "numMissing", len(missingKeys)) | ||
|
|
||
| memR.mempool.jsonMetrics.Lock() | ||
| memR.mempool.jsonMetrics.TransactionsMissing = append(memR.mempool.jsonMetrics.TransactionsMissing, uint64(len(missingKeys))) | ||
| memR.mempool.jsonMetrics.Transactions = append(memR.mempool.jsonMetrics.Transactions, uint64(len(compactData))) | ||
| // Check if we got lucky and already had all the transactions. | ||
| if len(missingKeys) == 0 { | ||
| memR.mempool.jsonMetrics.TimeTakenFetchingTxs = append(memR.mempool.jsonMetrics.TimeTakenFetchingTxs, 0) | ||
| memR.mempool.jsonMetrics.Unlock() | ||
| return txs, nil | ||
| } | ||
| memR.mempool.jsonMetrics.Unlock() | ||
|
|
||
| // setup a request for this block and begin to track and retrieve all missing transactions | ||
| request := memR.blockFetcher.NewRequest( | ||
| blockID, | ||
| memR.mempool.Height(), | ||
| missingKeys, | ||
| txs, | ||
| ) | ||
| defer func() { | ||
| timeTaken := request.TimeTaken() | ||
| if timeTaken == 0 { | ||
| return | ||
| } | ||
|
There was a problem hiding this comment. It's for gathering metrics |
||
| memR.mempool.jsonMetrics.Lock() | ||
| memR.mempool.jsonMetrics.TimeTakenFetchingTxs = append(memR.mempool.jsonMetrics.TimeTakenFetchingTxs, timeTaken) | ||
| memR.mempool.jsonMetrics.Unlock() | ||
| }() | ||
|
|
||
| // Wait for the reactor to retrieve and post all transactions. | ||
| return request.WaitForBlock(ctx) | ||
| } | ||
|
|
||
| // FetchKeysFromTxs is in many ways the opposite method. It takes a full block generated by the application | ||
| // and reduces it to the set of keys that need to be gossiped from one mempool to another nodes mempool | ||
| // in order to recreate the full block. | ||
| func (memR *Reactor) FetchKeysFromTxs(ctx context.Context, txs [][]byte) ([][]byte, error) { | ||
| keys := make([][]byte, len(txs)) | ||
| for idx, tx := range txs { | ||
| // check if the context has been cancelled | ||
| if ctx.Err() != nil { | ||
| return nil, ctx.Err() | ||
| } | ||
| key := types.Tx(tx).Key() | ||
| keys[idx] = key[:] | ||
| has := memR.mempool.store.has(key) | ||
| if !has { | ||
| // If the mempool provided the initial transactions yet received from | ||
| // consensus a transaction it doesn't recognize, this implies that | ||
| // either a tx was mutated or was added by the application. In either | ||
| // case, it is likely no other mempool has this transaction so we | ||
| // preemptively broadcast it to all other peers | ||
| // | ||
| // We don't set the priority, gasWanted or sender fields because we | ||
| // don't know them. | ||
| wtx := newWrappedTx(tx, key, memR.mempool.Height(), 0, 0, "") | ||
| memR.broadcastNewTx(wtx) | ||
| // For safety we also store this transaction in the mempool (ignoring | ||
| // all size limits) so that we can retrieve it later if needed. Note | ||
| // as we're broadcasting it to all peers, we should not receive a `WantTx` | ||
| // unless it gets rejected by the application in CheckTx. | ||
| // | ||
| // Consensus will have an in memory copy of the entire block which includes | ||
| // this transaction so it should not need it. | ||
| memR.mempool.store.set(wtx) | ||
| } | ||
|
There was a problem hiding this comment. do we need to call checktx to avoid accidently including invalid txs? |
||
| } | ||
|
|
||
| // return the keys back to the consensus engine | ||
| return keys, nil | ||
| } | ||
|
|
||
| type blockFetcher struct { | ||
| // mutex to manage concurrent calls to different parts | ||
| mtx sync.Mutex | ||
| // requests are a map of all processing block requests | ||
| // by blockID. | ||
| requests map[string]*blockRequest | ||
| } | ||
|
|
||
| // NewBlockFetcher returns a new blockFetcher for managing block requests | ||
| func NewBlockFetcher() *blockFetcher { | ||
| return &blockFetcher{ | ||
| requests: make(map[string]*blockRequest), | ||
| } | ||
| } | ||
|
|
||
| func (bf *blockFetcher) GetRequest(blockID []byte) (*blockRequest, bool) { | ||
| bf.mtx.Lock() | ||
| defer bf.mtx.Unlock() | ||
| request, ok := bf.requests[string(blockID)] | ||
| return request, ok | ||
| } | ||
|
|
||
| // NewRequest creates a new block request and returns it. | ||
| // If a request already exists it returns that instead | ||
| func (bf *blockFetcher) NewRequest( | ||
| blockID []byte, | ||
| height int64, | ||
| missingKeys map[int]types.TxKey, | ||
| txs [][]byte, | ||
| ) *blockRequest { | ||
| bf.mtx.Lock() | ||
| defer bf.mtx.Unlock() | ||
| if request, ok := bf.requests[string(blockID)]; ok { | ||
| return request | ||
| } | ||
| request := NewBlockRequest(height, missingKeys, txs) | ||
| bf.requests[string(blockID)] = request | ||
| bf.pruneOldRequests(height) | ||
| return request | ||
| } | ||
|
|
||
| // TryAddMissingTx loops through all current requests and tries to add | ||
| // the given transaction (if it is missing). | ||
| func (bf *blockFetcher) TryAddMissingTx(key types.TxKey, tx []byte) { | ||
| bf.mtx.Lock() | ||
| defer bf.mtx.Unlock() | ||
| for _, request := range bf.requests { | ||
| request.TryAddMissingTx(key, tx) | ||
| } | ||
| } | ||
|
|
||
| // PruneOldRequests removes any requests that are older than the given height. | ||
| func (bf *blockFetcher) pruneOldRequests(height int64) { | ||
| for blockID, request := range bf.requests { | ||
| if request.height < height { | ||
| delete(bf.requests, blockID) | ||
| } | ||
| } | ||
| } | ||
|
|
||
| // blockRequests handle the lifecycle of individual block requests. | ||
| type blockRequest struct { | ||
| // immutable fields | ||
| height int64 | ||
| doneCh chan struct{} | ||
|
|
||
| mtx sync.Mutex | ||
| // track the remaining keys that are missing | ||
| missingKeysByIndex map[int]types.TxKey | ||
| missingKeys map[string]int | ||
| // the txs in the block | ||
| txs [][]byte | ||
|
|
||
| // used for metrics | ||
| startTime time.Time | ||
| endTime time.Time | ||
| } | ||
|
|
||
| func NewBlockRequest( | ||
| height int64, | ||
| missingKeys map[int]types.TxKey, | ||
| txs [][]byte, | ||
| ) *blockRequest { | ||
| mk := make(map[string]int, len(missingKeys)) | ||
| for i, key := range missingKeys { | ||
| mk[key.String()] = i | ||
| } | ||
| return &blockRequest{ | ||
| height: height, | ||
| missingKeysByIndex: missingKeys, | ||
| missingKeys: mk, | ||
| txs: txs, | ||
| doneCh: make(chan struct{}), | ||
| startTime: time.Now().UTC(), | ||
| } | ||
| } | ||
|
|
||
| // WaitForBlock is a blocking call that waits for the block to be fetched and completed. | ||
| // It can be called concurrently. If the block was already fetched it returns immediately. | ||
| func (br *blockRequest) WaitForBlock(ctx context.Context) ([][]byte, error) { | ||
| if br.IsDone() { | ||
| return br.txs, nil | ||
| } | ||
|
|
||
| for { | ||
| select { | ||
| case <-ctx.Done(): | ||
| return nil, ctx.Err() | ||
| case <-br.doneCh: | ||
| br.mtx.Lock() | ||
| defer br.mtx.Unlock() | ||
| br.endTime = time.Now().UTC() | ||
| return br.txs, nil | ||
| } | ||
| } | ||
| } | ||
|
|
||
| // TryAddMissingTx checks if a given transactions was missing and if so | ||
| // adds it to the block request. | ||
| func (br *blockRequest) TryAddMissingTx(key types.TxKey, tx []byte) bool { | ||
| br.mtx.Lock() | ||
| defer br.mtx.Unlock() | ||
| if index, ok := br.missingKeys[key.String()]; ok { | ||
| delete(br.missingKeys, key.String()) | ||
| delete(br.missingKeysByIndex, index) | ||
| br.txs[index] = tx | ||
| // check if there is any more transactions remaining | ||
| if len(br.missingKeys) == 0 { | ||
| // Yaay! We're done! | ||
| close(br.doneCh) | ||
| } | ||
| return true | ||
| } | ||
| return false | ||
| } | ||
|
|
||
| // IsDone returns whether all transactions in the block have been received. | ||
| // This is done by measuring the amount of missing keys. | ||
| func (br *blockRequest) IsDone() bool { | ||
| br.mtx.Lock() | ||
| defer br.mtx.Unlock() | ||
| return len(br.missingKeys) == 0 | ||
| } | ||
|
|
||
| func (br *blockRequest) TimeTaken() uint64 { | ||
| if br.endTime.IsZero() { | ||
| return 0 | ||
| } | ||
| return uint64(br.endTime.Sub(br.startTime).Milliseconds()) | ||
| } | ||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,243 @@ | ||
| package cat | ||
|
|
||
| import ( | ||
| "context" | ||
| "fmt" | ||
| "math/rand" | ||
| "sync" | ||
| "testing" | ||
| "time" | ||
|
|
||
| "github.com/tendermint/tendermint/crypto/tmhash" | ||
| "github.com/tendermint/tendermint/mempool" | ||
| "github.com/tendermint/tendermint/p2p" | ||
| memproto "github.com/tendermint/tendermint/proto/tendermint/mempool" | ||
| "github.com/tendermint/tendermint/types" | ||
| "github.com/stretchr/testify/require" | ||
| ) | ||
|
|
||
| func TestBlockRequest(t *testing.T) { | ||
| ctx, cancel := context.WithTimeout(context.Background(), time.Second) | ||
| defer cancel() | ||
| tx1, tx2 := types.Tx("hello"), types.Tx("world") | ||
| key1, key2 := tx1.Key(), tx2.Key() | ||
| txs := make([][]byte, 2) | ||
| missingKeys := map[int]types.TxKey{ | ||
| 0: key1, | ||
| 1: key2, | ||
| } | ||
|
|
||
| request := NewBlockRequest(1, missingKeys, txs) | ||
|
|
||
| require.True(t, request.TryAddMissingTx(key1, tx1)) | ||
| // cannot add the same missing tx twice | ||
| require.False(t, request.TryAddMissingTx(key1, tx1)) | ||
| require.False(t, request.IsDone()) | ||
|
|
||
| // test that we adhere to the context deadline | ||
| shortCtx, cancel := context.WithTimeout(context.Background(), time.Millisecond) | ||
| defer cancel() | ||
| _, err := request.WaitForBlock(shortCtx) | ||
| require.Error(t, err) | ||
|
|
||
| // test that all txs mean the block `IsDone` | ||
| require.True(t, request.TryAddMissingTx(key2, tx2)) | ||
| require.True(t, request.IsDone()) | ||
|
|
||
| // waiting for the block should instantly return | ||
| txs, err = request.WaitForBlock(ctx) | ||
| require.NoError(t, err) | ||
| require.Equal(t, txs, [][]byte{tx1, tx2}) | ||
| } | ||
|
|
||
| func TestBlockRequestConcurrently(t *testing.T) { | ||
| ctx, cancel := context.WithTimeout(context.Background(), time.Second) | ||
| defer cancel() | ||
| const numTxs = 10 | ||
| allTxs := make([][]byte, numTxs) | ||
| txKeys := make([]types.TxKey, numTxs) | ||
| missingKeys := make(map[int]types.TxKey) | ||
| txs := make([][]byte, numTxs) | ||
| for i := 0; i < numTxs; i++ { | ||
| tx := types.Tx(fmt.Sprintf("tx%d", i)) | ||
| allTxs[i] = tx | ||
| txKeys[i] = tx.Key() | ||
| if i%3 == 0 { | ||
| txs[i] = tx | ||
| } else { | ||
| missingKeys[i] = txKeys[i] | ||
| } | ||
| } | ||
|
|
||
| request := NewBlockRequest(1, missingKeys, txs) | ||
|
|
||
| wg := sync.WaitGroup{} | ||
| for i := 0; i < numTxs; i++ { | ||
| wg.Add(1) | ||
| go func(i int) { | ||
| defer wg.Done() | ||
| request.TryAddMissingTx(txKeys[i], txs[i]) | ||
| }(i) | ||
| } | ||
|
|
||
| // wait for the block | ||
| result, err := request.WaitForBlock(ctx) | ||
| require.NoError(t, err) | ||
| require.Len(t, result, numTxs) | ||
| for i := 0; i < numTxs; i++ { | ||
| require.Equal(t, string(result[i]), string(txs[i])) | ||
| } | ||
| wg.Wait() | ||
| } | ||
|
|
||
| func TestBlockFetcherSimple(t *testing.T) { | ||
| bf := NewBlockFetcher() | ||
| tx := types.Tx("hello world") | ||
| key := tx.Key() | ||
| missingKeys := map[int]types.TxKey{ | ||
| 0: key, | ||
| } | ||
| blockID := []byte("blockID") | ||
| req := bf.NewRequest(blockID, 1, missingKeys, make([][]byte, 1)) | ||
| req2, ok := bf.GetRequest(blockID) | ||
| require.True(t, ok) | ||
| require.Equal(t, req, req2) | ||
| // a different request for the same blockID should | ||
| // return the same original request object. | ||
| req3 := bf.NewRequest(blockID, 2, missingKeys, make([][]byte, 2)) | ||
| require.Equal(t, req, req3) | ||
|
|
||
| req4 := bf.NewRequest([]byte("differentBlockID"), 1, missingKeys, make([][]byte, 1)) | ||
|
|
||
| bf.TryAddMissingTx(key, tx) | ||
| require.False(t, req4.TryAddMissingTx(key, tx)) | ||
| require.True(t, req.IsDone()) | ||
| require.Len(t, bf.requests, 2) | ||
| } | ||
|
|
||
| func TestBlockFetcherConcurrentRequests(t *testing.T) { | ||
| var ( | ||
| bf = NewBlockFetcher() | ||
| numBlocks = 5 | ||
| numRequestsPerBlock = 5 | ||
| numTxs = 5 | ||
| requestWG = sync.WaitGroup{} | ||
| goRoutinesWG = sync.WaitGroup{} | ||
| allTxs = make([][]byte, numTxs) | ||
| txs = make([][]byte, numTxs) | ||
| missingKeys = make(map[int]types.TxKey) | ||
| ) | ||
|
|
||
| ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) | ||
| defer cancel() | ||
|
|
||
| for i := 0; i < numTxs; i++ { | ||
| tx := types.Tx(fmt.Sprintf("tx%d", i)) | ||
| allTxs[i] = tx | ||
| if i%3 == 0 { | ||
| txs[i] = tx | ||
| } else { | ||
| missingKeys[i] = tx.Key() | ||
| } | ||
| } | ||
|
|
||
| for i := 0; i < numBlocks; i++ { | ||
| requestWG.Add(1) | ||
| for j := 0; j < numRequestsPerBlock; j++ { | ||
| goRoutinesWG.Add(1) | ||
| go func(blockID []byte, routine int) { | ||
| defer goRoutinesWG.Done() | ||
| // create a copy of the missingKeys and txs | ||
| mk := make(map[int]types.TxKey) | ||
| for i, k := range missingKeys { | ||
| mk[i] = k | ||
| } | ||
| txsCopy := make([][]byte, len(txs)) | ||
| copy(txsCopy, txs) | ||
| request := bf.NewRequest(blockID, 1, mk, txs) | ||
| if routine == 0 { | ||
| requestWG.Done() | ||
| } | ||
| _, _ = request.WaitForBlock(ctx) | ||
| }([]byte(fmt.Sprintf("blockID%d", i)), j) | ||
| } | ||
| goRoutinesWG.Add(1) | ||
| go func() { | ||
| defer goRoutinesWG.Done() | ||
| // Wait until all the request have started | ||
| requestWG.Wait() | ||
| for _, tx := range allTxs { | ||
| bf.TryAddMissingTx(types.Tx(tx).Key(), tx) | ||
| } | ||
| }() | ||
| } | ||
| goRoutinesWG.Wait() | ||
|
|
||
| for i := 0; i < numBlocks; i++ { | ||
| blockID := []byte(fmt.Sprintf("blockID%d", i)) | ||
| request, ok := bf.GetRequest(blockID) | ||
| require.True(t, ok) | ||
| require.True(t, request.IsDone()) | ||
| result, err := request.WaitForBlock(ctx) | ||
| require.NoError(t, err) | ||
| require.Equal(t, result, txs) | ||
| } | ||
| } | ||
|
|
||
| func TestFetchTxsFromKeys(t *testing.T) { | ||
| ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) | ||
| defer cancel() | ||
| reactor, pool := setupReactor(t) | ||
|
|
||
| numTxs := 10 | ||
| txs := make([][]byte, numTxs) | ||
| keys := make([][]byte, numTxs) | ||
| peer := genPeer() | ||
| blockID := tmhash.Sum([]byte("blockID")) | ||
|
There was a problem hiding this comment. is the block id used to check anything or does it just serve as an index? |
||
| wg := sync.WaitGroup{} | ||
| for i := 0; i < numTxs; i++ { | ||
| tx := newDefaultTx(fmt.Sprintf("tx%d", i)) | ||
| txs[i] = tx | ||
| key := tx.Key() | ||
| keys[i] = key[:] | ||
| // every 1 in 3 transactions proposed in the block, the node | ||
| // already has in their mempool and doesn't need to fetch | ||
| if i%3 == 0 { | ||
| t.Log("adding tx to mempool", i) | ||
| err := pool.CheckTx(tx, nil, mempool.TxInfo{}) | ||
| require.NoError(t, err) | ||
| } else { | ||
| wg.Add(1) | ||
| go func() { | ||
| defer wg.Done() | ||
| time.Sleep(time.Duration(rand.Int63n(100)) * time.Millisecond) | ||
| reactor.ReceiveEnvelope(p2p.Envelope{ | ||
| Src: peer, | ||
| Message: &memproto.Txs{Txs: [][]byte{tx}}, | ||
| ChannelID: mempool.MempoolChannel, | ||
| }) | ||
| }() | ||
| } | ||
| } | ||
|
|
||
| reactor.InitPeer(peer) | ||
|
|
||
| go func() { | ||
| reactor.ReceiveEnvelope(p2p.Envelope{ | ||
| Src: peer, | ||
| Message: &memproto.Txs{Txs: txs}, | ||
| ChannelID: mempool.MempoolChannel, | ||
| }) | ||
| }() | ||
|
Comment on lines
+224
to
+230
There was a problem hiding this comment. are we intenting to send all the txs to ourselves? I'm assuming no, since we are explicitly delaying the txs earlier and we can delete this and the test still passes. |
||
|
|
||
| resultTxs, err := reactor.FetchTxsFromKeys(ctx, blockID, keys) | ||
| require.NoError(t, err) | ||
| require.Equal(t, len(txs), len(resultTxs)) | ||
| for idx, tx := range resultTxs { | ||
| require.Equal(t, txs[idx], tx) | ||
| } | ||
| repeatResult, err := reactor.FetchTxsFromKeys(ctx, blockID, keys) | ||
| require.NoError(t, err) | ||
| require.Equal(t, resultTxs, repeatResult) | ||
| wg.Wait() | ||
|
Comment on lines
+232
to
+241
There was a problem hiding this comment. what does repeating and comparing test? can we document this if its something not obvious or benign? There was a problem hiding this comment. I think it might be to hit the cache |
||
| } | ||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
note for after prototype: we need var names plus more dovs here