diff options
author | Péter Szilágyi <peterke@gmail.com> | 2018-06-04 19:09:16 +0800 |
---|---|---|
committer | Péter Szilágyi <peterke@gmail.com> | 2018-06-05 16:03:55 +0800 |
commit | 2ab24a2a8f864e8c2f3c7ad2d494ccf02ffd8384 (patch) | |
tree | ff4442a8da2b097e804a14b1255fee8ba3376b72 /core/tx_cacher.go | |
parent | 400332b99d4eacb6aa509339fa39460b68f76ee7 (diff) | |
download | dexon-2ab24a2a8f864e8c2f3c7ad2d494ccf02ffd8384.tar dexon-2ab24a2a8f864e8c2f3c7ad2d494ccf02ffd8384.tar.gz dexon-2ab24a2a8f864e8c2f3c7ad2d494ccf02ffd8384.tar.bz2 dexon-2ab24a2a8f864e8c2f3c7ad2d494ccf02ffd8384.tar.lz dexon-2ab24a2a8f864e8c2f3c7ad2d494ccf02ffd8384.tar.xz dexon-2ab24a2a8f864e8c2f3c7ad2d494ccf02ffd8384.tar.zst dexon-2ab24a2a8f864e8c2f3c7ad2d494ccf02ffd8384.zip |
core: concurrent background transaction sender ecrecover
Diffstat (limited to 'core/tx_cacher.go')
-rw-r--r-- | core/tx_cacher.go | 105 |
1 files changed, 105 insertions, 0 deletions
diff --git a/core/tx_cacher.go b/core/tx_cacher.go new file mode 100644 index 000000000..6d989c83d --- /dev/null +++ b/core/tx_cacher.go @@ -0,0 +1,105 @@ +// Copyright 2018 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package core + +import ( + "runtime" + + "github.com/ethereum/go-ethereum/core/types" +) + +// senderCacher is a concurrent tranaction sender recoverer anc cacher. +var senderCacher = newTxSenderCacher(runtime.NumCPU()) + +// txSenderCacherRequest is a request for recovering transaction senders with a +// specific signature scheme and caching it into the transactions themselves. +// +// The inc field defines the number of transactions to skip after each recovery, +// which is used to feed the same underlying input array to different threads but +// ensure they process the early transactions fast. +type txSenderCacherRequest struct { + signer types.Signer + txs []*types.Transaction + inc int +} + +// txSenderCacher is a helper structure to concurrently ecrecover transaction +// senders from digital signatures on background threads. +type txSenderCacher struct { + threads int + tasks chan *txSenderCacherRequest +} + +// newTxSenderCacher creates a new transaction sender background cacher and starts +// as many procesing goroutines as allowed by the GOMAXPROCS on construction. +func newTxSenderCacher(threads int) *txSenderCacher { + cacher := &txSenderCacher{ + tasks: make(chan *txSenderCacherRequest, threads), + threads: threads, + } + for i := 0; i < threads; i++ { + go cacher.cache() + } + return cacher +} + +// cache is an infinite loop, caching transaction senders from various forms of +// data structures. +func (cacher *txSenderCacher) cache() { + for task := range cacher.tasks { + for i := 0; i < len(task.txs); i += task.inc { + types.Sender(task.signer, task.txs[i]) + } + } +} + +// recover recovers the senders from a batch of transactions and caches them +// back into the same data structures. There is no validation being done, nor +// any reaction to invalid signatures. That is up to calling code later. +func (cacher *txSenderCacher) recover(signer types.Signer, txs []*types.Transaction) { + // If there's nothing to recover, abort + if len(txs) == 0 { + return + } + // Ensure we have meaningful task sizes and schedule the recoveries + tasks := cacher.threads + if len(txs) < tasks*4 { + tasks = (len(txs) + 3) / 4 + } + for i := 0; i < tasks; i++ { + cacher.tasks <- &txSenderCacherRequest{ + signer: signer, + txs: txs[i:], + inc: tasks, + } + } +} + +// recoverFromBlocks recovers the senders from a batch of blocks and caches them +// back into the same data structures. There is no validation being done, nor +// any reaction to invalid signatures. That is up to calling code later. +func (cacher *txSenderCacher) recoverFromBlocks(signer types.Signer, blocks []*types.Block) { + count := 0 + for _, block := range blocks { + count += len(block.Transactions()) + } + txs := make([]*types.Transaction, 0, count) + for _, block := range blocks { + txs = append(txs, block.Transactions()...) + } + cacher.recover(signer, txs) +} |