tornadocontrib/go-ethereum
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

core, core/vm, core/state: remove unused functions

Browse Source
This commit is contained in:
Gustav Simonsson 2015-09-10 15:24:36 +02:00
parent 90f1fe0ed2
commit b81a6e6ab8
6 changed files with 0 additions and 281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

120
core/block_cache.go
View File

@ -1,120 +0,0 @@
// Copyright 2015 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 (
"sync"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types"
)
// BlockCache implements a caching mechanism specifically for blocks and uses FILO to pop
type BlockCache struct {
size int
hashes []common.Hash
blocks map[common.Hash]*types.Block
mu sync.RWMutex
}
// Creates and returns a `BlockCache` with `size`. If `size` is smaller than 1 it will panic
func NewBlockCache(size int) *BlockCache {
if size < 1 {
panic("block cache size not allowed to be smaller than 1")
}
bc := &BlockCache{size: size}
bc.Clear()
return bc
}
func (bc *BlockCache) Clear() {
bc.blocks = make(map[common.Hash]*types.Block)
bc.hashes = nil
}
func (bc *BlockCache) Push(block *types.Block) {
bc.mu.Lock()
defer bc.mu.Unlock()
if len(bc.hashes) == bc.size {
delete(bc.blocks, bc.hashes[0])
// XXX There are a few other options on solving this
// 1) use a poller / GC like mechanism to clean up untracked objects
// 2) copy as below
// re-use the slice and remove the reference to bc.hashes[0]
// this will allow the element to be garbage collected.
copy(bc.hashes, bc.hashes[1:])
} else {
bc.hashes = append(bc.hashes, common.Hash{})
}
hash := block.Hash()
bc.blocks[hash] = block
bc.hashes[len(bc.hashes)-1] = hash
}
func (bc *BlockCache) Delete(hash common.Hash) {
bc.mu.Lock()
defer bc.mu.Unlock()
if _, ok := bc.blocks[hash]; ok {
delete(bc.blocks, hash)
for i, h := range bc.hashes {
if hash == h {
bc.hashes = bc.hashes[:i+copy(bc.hashes[i:], bc.hashes[i+1:])]
// or ? => bc.hashes = append(bc.hashes[:i], bc.hashes[i+1]...)
break
}
}
}
}
func (bc *BlockCache) Get(hash common.Hash) *types.Block {
bc.mu.RLock()
defer bc.mu.RUnlock()
if block, haz := bc.blocks[hash]; haz {
return block
}
return nil
}
func (bc *BlockCache) Has(hash common.Hash) bool {
bc.mu.RLock()
defer bc.mu.RUnlock()
_, ok := bc.blocks[hash]
return ok
}
func (bc *BlockCache) Each(cb func(int, *types.Block)) {
bc.mu.Lock()
defer bc.mu.Unlock()
i := 0
for _, block := range bc.blocks {
cb(i, block)
i++
}
}

76
core/block_cache_test.go
View File

@ -1,76 +0,0 @@
// Copyright 2015 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 (
"math/big"
"testing"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types"
)
func newChain(size int) (chain []*types.Block) {
var parentHash common.Hash
for i := 0; i < size; i++ {
head := &types.Header{ParentHash: parentHash, Number: big.NewInt(int64(i))}
block := types.NewBlock(head, nil, nil, nil)
chain = append(chain, block)
parentHash = block.Hash()
}
return chain
}
func insertChainCache(cache *BlockCache, chain []*types.Block) {
for _, block := range chain {
cache.Push(block)
}
}
func TestNewBlockCache(t *testing.T) {
chain := newChain(3)
cache := NewBlockCache(2)
insertChainCache(cache, chain)
if cache.hashes[0] != chain[1].Hash() {
t.Error("oldest block incorrect")
}
}
func TestInclusion(t *testing.T) {
chain := newChain(3)
cache := NewBlockCache(3)
insertChainCache(cache, chain)
for _, block := range chain {
if b := cache.Get(block.Hash()); b == nil {
t.Errorf("getting %x failed", block.Hash())
}
}
}
func TestDeletion(t *testing.T) {
chain := newChain(3)
cache := NewBlockCache(3)
insertChainCache(cache, chain)
cache.Delete(chain[1].Hash())
if cache.Has(chain[1].Hash()) {
t.Errorf("expected %x not to be included")
}
}

43
core/state/state_object.go
View File

@ -87,10 +87,6 @@ type StateObject struct {
dirty bool dirty bool
} }
func (self *StateObject) Reset() {
self.storage = make(Storage)
}
func NewStateObject(address common.Address, db common.Database) *StateObject { func NewStateObject(address common.Address, db common.Database) *StateObject {
object := &StateObject{db: db, address: address, balance: new(big.Int), gasPool: new(big.Int), dirty: true} object := &StateObject{db: db, address: address, balance: new(big.Int), gasPool: new(big.Int), dirty: true}
object.trie = trie.NewSecure((common.Hash{}).Bytes(), db) object.trie = trie.NewSecure((common.Hash{}).Bytes(), db)
@ -184,14 +180,6 @@ func (self *StateObject) Update() {
} }
} }
func (c *StateObject) GetInstr(pc *big.Int) *common.Value {
if int64(len(c.code)-1) < pc.Int64() {
return common.NewValue(0)
}
return common.NewValueFromBytes([]byte{c.code[pc.Int64()]})
}
func (c *StateObject) AddBalance(amount *big.Int) { func (c *StateObject) AddBalance(amount *big.Int) {
c.SetBalance(new(big.Int).Add(c.balance, amount)) c.SetBalance(new(big.Int).Add(c.balance, amount))
@ -268,10 +256,6 @@ func (self *StateObject) Copy() *StateObject {
return stateObject return stateObject
} }
func (self *StateObject) Set(stateObject *StateObject) {
*self = *stateObject
}
// //
// Attribute accessors // Attribute accessors
// //
@ -280,20 +264,11 @@ func (self *StateObject) Balance() *big.Int {
return self.balance return self.balance
} }
func (c *StateObject) N() *big.Int {
return big.NewInt(int64(c.nonce))
}
// Returns the address of the contract/account // Returns the address of the contract/account
func (c *StateObject) Address() common.Address { func (c *StateObject) Address() common.Address {
return c.address return c.address
} }
// Returns the initialization Code
func (c *StateObject) Init() Code {
return c.initCode
}
func (self *StateObject) Trie() *trie.SecureTrie { func (self *StateObject) Trie() *trie.SecureTrie {
return self.trie return self.trie
} }
@ -311,11 +286,6 @@ func (self *StateObject) SetCode(code []byte) {
self.dirty = true self.dirty = true
} }
func (self *StateObject) SetInitCode(code []byte) {
self.initCode = code
self.dirty = true
}
func (self *StateObject) SetNonce(nonce uint64) { func (self *StateObject) SetNonce(nonce uint64) {
self.nonce = nonce self.nonce = nonce
self.dirty = true self.dirty = true
@ -354,19 +324,6 @@ func (c *StateObject) CodeHash() common.Bytes {
return crypto.Sha3(c.code) return crypto.Sha3(c.code)
} }
func (c *StateObject) RlpDecode(data []byte) {
decoder := common.NewValueFromBytes(data)
c.nonce = decoder.Get(0).Uint()
c.balance = decoder.Get(1).BigInt()
c.trie = trie.NewSecure(decoder.Get(2).Bytes(), c.db)
c.storage = make(map[string]common.Hash)
c.gasPool = new(big.Int)
c.codeHash = decoder.Get(3).Bytes()
c.code, _ = c.db.Get(c.codeHash)
}
// Storage change object. Used by the manifest for notifying changes to // Storage change object. Used by the manifest for notifying changes to
// the sub channels. // the sub channels.
type StorageState struct { type StorageState struct {

21
core/state/statedb.go
View File

@ -18,7 +18,6 @@
package state package state
import ( import (
"bytes"
"math/big" "math/big"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
@ -276,10 +275,6 @@ func (self *StateDB) CreateAccount(addr common.Address) *StateObject {
// Setting, copying of the state methods // Setting, copying of the state methods
// //
func (s *StateDB) Cmp(other *StateDB) bool {
return bytes.Equal(s.trie.Root(), other.trie.Root())
}
func (self *StateDB) Copy() *StateDB { func (self *StateDB) Copy() *StateDB {
state := New(common.Hash{}, self.db) state := New(common.Hash{}, self.db)
state.trie = self.trie state.trie = self.trie
@ -311,22 +306,6 @@ func (s *StateDB) Root() common.Hash {
return common.BytesToHash(s.trie.Root()) return common.BytesToHash(s.trie.Root())
} }
func (s *StateDB) Trie() *trie.SecureTrie {
return s.trie
}
// Resets the trie and all siblings
func (s *StateDB) Reset() {
s.trie.Reset()
// Reset all nested states
for _, stateObject := range s.stateObjects {
stateObject.Reset()
}
s.Empty()
}
// Syncs the trie and all siblings // Syncs the trie and all siblings
func (s *StateDB) Sync() { func (s *StateDB) Sync() {
// Sync all nested states // Sync all nested states

4
core/types/transaction.go
View File

@ -33,10 +33,6 @@ import (
var ErrInvalidSig = errors.New("invalid v, r, s values") var ErrInvalidSig = errors.New("invalid v, r, s values")
func IsContractAddr(addr []byte) bool {
return len(addr) == 0
}
type Transaction struct { type Transaction struct {
data txdata data txdata
// caches // caches

17
core/vm/errors.go
View File

@ -25,20 +25,3 @@ import (
var OutOfGasError = errors.New("Out of gas") var OutOfGasError = errors.New("Out of gas")
var DepthError = fmt.Errorf("Max call depth exceeded (%d)", params.CallCreateDepth) var DepthError = fmt.Errorf("Max call depth exceeded (%d)", params.CallCreateDepth)
type StackError struct {
req, has int
}
func StackErr(req, has int) StackError {
return StackError{req, has}
}
func (self StackError) Error() string {
return fmt.Sprintf("stack error! require %v, have %v", self.req, self.has)
}
func IsStackErr(err error) bool {
_, ok := err.(StackError)
return ok
}