From 8a226502d011ba5778ce0f557fa762a2d4b5fa3a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Thu, 22 Jun 2017 14:38:15 +0300 Subject: [PATCH] trie: rename SyncMemCache to syncMemBatch --- trie/sync.go | 46 +++++++++++++++++++++++----------------------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/trie/sync.go b/trie/sync.go index c6524b2211..9e8449431d 100644 --- a/trie/sync.go +++ b/trie/sync.go @@ -52,17 +52,17 @@ type SyncResult struct { Data []byte // Data content of the retrieved node } -// SyncMemCache is an in-memory cache of successfully downloaded but not yet +// syncMemBatch is an in-memory buffer of successfully downloaded but not yet // persisted data items. -type SyncMemCache struct { - cache map[common.Hash][]byte // In-memory memcache of recently ocmpleted items +type syncMemBatch struct { + batch map[common.Hash][]byte // In-memory membatch of recently ocmpleted items order []common.Hash // Order of completion to prevent out-of-order data loss } -// newSyncMemCache allocates a new memory-cache for not-yet persisted trie nodes. -func newSyncMemCache() *SyncMemCache { - return &SyncMemCache{ - cache: make(map[common.Hash][]byte), +// newSyncMemBatch allocates a new memory-buffer for not-yet persisted trie nodes. +func newSyncMemBatch() *syncMemBatch { + return &syncMemBatch{ + batch: make(map[common.Hash][]byte), order: make([]common.Hash, 0, 256), } } @@ -77,7 +77,7 @@ type TrieSyncLeafCallback func(leaf []byte, parent common.Hash) error // and reconstructs the trie step by step until all is done. type TrieSync struct { database DatabaseReader // Persistent database to check for existing entries - memcache *SyncMemCache // Memory cache to avoid frequest database writes + membatch *syncMemBatch // Memory buffer to avoid frequest database writes requests map[common.Hash]*request // Pending requests pertaining to a key hash queue *prque.Prque // Priority queue with the pending requests } @@ -86,7 +86,7 @@ type TrieSync struct { func NewTrieSync(root common.Hash, database DatabaseReader, callback TrieSyncLeafCallback) *TrieSync { ts := &TrieSync{ database: database, - memcache: newSyncMemCache(), + membatch: newSyncMemBatch(), requests: make(map[common.Hash]*request), queue: prque.New(), } @@ -100,7 +100,7 @@ func (s *TrieSync) AddSubTrie(root common.Hash, depth int, parent common.Hash, c if root == emptyRoot { return } - if _, ok := s.memcache.cache[root]; ok { + if _, ok := s.membatch.batch[root]; ok { return } key := root.Bytes() @@ -135,7 +135,7 @@ func (s *TrieSync) AddRawEntry(hash common.Hash, depth int, parent common.Hash) if hash == emptyState { return } - if _, ok := s.memcache.cache[hash]; ok { + if _, ok := s.membatch.batch[hash]; ok { return } if blob, _ := s.database.Get(hash.Bytes()); blob != nil { @@ -215,19 +215,19 @@ func (s *TrieSync) Process(results []SyncResult) (bool, int, error) { return committed, 0, nil } -// Commit flushes the data stored in the internal memcache out to persistent +// Commit flushes the data stored in the internal membatch out to persistent // storage, returning th enumber of items written and any occurred error. func (s *TrieSync) Commit(dbw DatabaseWriter) (int, error) { - // Dump the memcache into a database dbw - for i, key := range s.memcache.order { - if err := dbw.Put(key[:], s.memcache.cache[key]); err != nil { + // Dump the membatch into a database dbw + for i, key := range s.membatch.order { + if err := dbw.Put(key[:], s.membatch.batch[key]); err != nil { return i, err } } - written := len(s.memcache.order) + written := len(s.membatch.order) - // Drop the memcache data and return - s.memcache = newSyncMemCache() + // Drop the membatch data and return + s.membatch = newSyncMemBatch() return written, nil } @@ -293,7 +293,7 @@ func (s *TrieSync) children(req *request, object node) ([]*request, error) { if node, ok := (child.node).(hashNode); ok { // Try to resolve the node from the local database hash := common.BytesToHash(node) - if _, ok := s.memcache.cache[hash]; ok { + if _, ok := s.membatch.batch[hash]; ok { continue } blob, _ := s.database.Get(node) @@ -312,13 +312,13 @@ func (s *TrieSync) children(req *request, object node) ([]*request, error) { return requests, nil } -// commit finalizes a retrieval request and stores it into the memcache. If any +// commit finalizes a retrieval request and stores it into the membatch. If any // of the referencing parent requests complete due to this commit, they are also // committed themselves. func (s *TrieSync) commit(req *request) (err error) { - // Write the node content to the memcache - s.memcache.cache[req.hash] = req.data - s.memcache.order = append(s.memcache.order, req.hash) + // Write the node content to the membatch + s.membatch.batch[req.hash] = req.data + s.membatch.order = append(s.membatch.order, req.hash) delete(s.requests, req.hash)