OSDN Git Service

get BlockNode from database (#188)
[bytom/vapor.git] / database / cache.go
1 package database
2
3 import (
4         "strconv"
5
6         "github.com/golang/groupcache/singleflight"
7
8         "github.com/vapor/common"
9         "github.com/vapor/protocol/bc"
10         "github.com/vapor/protocol/bc/types"
11         "github.com/vapor/protocol/state"
12 )
13
14 const (
15         maxCachedBlockHeaders      = 4096
16         maxCachedBlockTransactions = 1024
17         maxCachedBlockHashes       = 8192
18         maxCachedMainChainHashes   = 8192
19         maxCachedVoteResults       = 128
20 )
21
22 type fillBlockHeaderFn func(hash *bc.Hash) (*types.BlockHeader, error)
23 type fillBlockTransactionsFn func(hash *bc.Hash) ([]*types.Tx, error)
24 type fillBlockHashesFn func(height uint64) ([]*bc.Hash, error)
25 type fillMainChainHashFn func(height uint64) (*bc.Hash, error)
26 type fillVoteResultFn func(seq uint64) (*state.VoteResult, error)
27
28 func newCache(fillBlockHeader fillBlockHeaderFn, fillBlockTxs fillBlockTransactionsFn, fillBlockHashes fillBlockHashesFn, fillMainChainHash fillMainChainHashFn, fillVoteResult fillVoteResultFn) cache {
29         return cache{
30                 lruBlockHeaders:    common.NewCache(maxCachedBlockHeaders),
31                 lruBlockTxs:        common.NewCache(maxCachedBlockTransactions),
32                 lruBlockHashes:     common.NewCache(maxCachedBlockHashes),
33                 lruMainChainHashes: common.NewCache(maxCachedMainChainHashes),
34                 lruVoteResults:     common.NewCache(maxCachedVoteResults),
35
36                 fillBlockHeaderFn:      fillBlockHeader,
37                 fillBlockTransactionFn: fillBlockTxs,
38                 fillBlockHashesFn:      fillBlockHashes,
39                 fillMainChainHashFn:    fillMainChainHash,
40                 fillVoteResultFn:       fillVoteResult,
41         }
42 }
43
44 type cache struct {
45         lruBlockHeaders    *common.Cache
46         lruBlockTxs        *common.Cache
47         lruBlockHashes     *common.Cache
48         lruMainChainHashes *common.Cache
49         lruVoteResults     *common.Cache
50
51         fillBlockHeaderFn      func(hash *bc.Hash) (*types.BlockHeader, error)
52         fillBlockTransactionFn func(hash *bc.Hash) ([]*types.Tx, error)
53         fillBlockHashesFn      func(uint64) ([]*bc.Hash, error)
54         fillMainChainHashFn    func(uint64) (*bc.Hash, error)
55         fillVoteResultFn       func(seq uint64) (*state.VoteResult, error)
56
57         sf singleflight.Group
58 }
59
60 func (c *cache) lookupBlockHeader(hash *bc.Hash) (*types.BlockHeader, error) {
61         if data, ok := c.lruBlockHeaders.Get(*hash); ok {
62                 return data.(*types.BlockHeader), nil
63         }
64
65         blockHeader, err := c.sf.Do("BlockHeader:"+hash.String(), func() (interface{}, error) {
66                 blockHeader, err := c.fillBlockHeaderFn(hash)
67                 if err != nil {
68                         return nil, err
69                 }
70
71                 c.lruBlockHeaders.Add(blockHeader.Hash(), blockHeader)
72                 return blockHeader, nil
73         })
74         if err != nil {
75                 return nil, err
76         }
77         return blockHeader.(*types.BlockHeader), nil
78 }
79
80 func (c *cache) lookupBlockTxs(hash *bc.Hash) ([]*types.Tx, error) {
81         if data, ok := c.lruBlockTxs.Get(*hash); ok {
82                 return data.([]*types.Tx), nil
83         }
84
85         blockTxs, err := c.sf.Do("BlockTxs:"+hash.String(), func() (interface{}, error) {
86                 blockTxs, err := c.fillBlockTransactionFn(hash)
87                 if err != nil {
88                         return nil, err
89                 }
90
91                 c.lruBlockTxs.Add(*hash, blockTxs)
92                 return blockTxs, nil
93         })
94         if err != nil {
95                 return nil, err
96         }
97         return blockTxs.([]*types.Tx), nil
98 }
99
100 func (c *cache) lookupVoteResult(seq uint64) (*state.VoteResult, error) {
101         if data, ok := c.lruVoteResults.Get(seq); ok {
102                 return data.(*state.VoteResult).Fork(), nil
103         }
104
105         seqStr := strconv.FormatUint(seq, 10)
106         voteResult, err := c.sf.Do("VoteResult:"+seqStr, func() (interface{}, error) {
107                 voteResult, err := c.fillVoteResultFn(seq)
108                 if err != nil {
109                         return nil, err
110                 }
111
112                 c.lruVoteResults.Add(voteResult.Seq, voteResult)
113                 return voteResult, nil
114         })
115         if err != nil {
116                 return nil, err
117         }
118         return voteResult.(*state.VoteResult).Fork(), nil
119 }
120
121 func (c *cache) lookupMainChainHash(height uint64) (*bc.Hash, error) {
122         if hash, ok := c.lruMainChainHashes.Get(height); ok {
123                 return hash.(*bc.Hash), nil
124         }
125
126         heightStr := strconv.FormatUint(height, 10)
127         hash, err := c.sf.Do("BlockHashByHeight:"+heightStr, func() (interface{}, error) {
128                 hash, err := c.fillMainChainHashFn(height)
129                 if err != nil {
130                         return nil, err
131                 }
132
133                 c.lruMainChainHashes.Add(height, hash)
134                 return hash, nil
135         })
136         if err != nil {
137                 return nil, err
138         }
139         return hash.(*bc.Hash), nil
140 }
141
142 func (c *cache) lookupBlockHashesByHeight(height uint64) ([]*bc.Hash, error) {
143         if hashes, ok := c.lruBlockHashes.Get(height); ok {
144                 return hashes.([]*bc.Hash), nil
145         }
146
147         heightStr := strconv.FormatUint(height, 10)
148         hashes, err := c.sf.Do("BlockHashesByHeight:"+heightStr, func() (interface{}, error) {
149                 hashes, err := c.fillBlockHashesFn(height)
150                 if err != nil {
151                         return nil, err
152                 }
153
154                 c.lruBlockHashes.Add(height, hashes)
155                 return hashes, nil
156         })
157         if err != nil {
158                 return nil, err
159         }
160         return hashes.([]*bc.Hash), nil
161 }
162
163 func (c *cache) removeBlockHeader(blockHeader *types.BlockHeader) {
164         c.lruBlockHeaders.Remove(blockHeader.Hash())
165 }
166
167 func (c *cache) removeBlockHashes(height uint64) {
168         c.lruBlockHashes.Remove(height)
169 }
170
171 func (c *cache) removeMainChainHash(height uint64) {
172         c.lruMainChainHashes.Remove(height)
173 }
174
175 func (c *cache) removeVoteResult(voteResult *state.VoteResult) {
176         c.lruVoteResults.Remove(voteResult.Seq)
177 }