mirror
/
go-ethereum
mirror of https://github.com/ethereum/go-ethereum
2
0
Fork 1
Code Issues Releases Wiki Activity

Merge pull request #1789 from Gustav-Simonsson/core_remove_unused_functions

Browse Source 
core, core/vm, core/state: remove unused functions
pull/1786/head
Jeffrey Wilcke 9 years ago
parent f1a4b330dd b81a6e6ab8
commit 55ed8d108d
6 changed files with 0 additions and 281 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 120
      core/block_cache.go
  2. 76
      core/block_cache_test.go
  3. 43
      core/state/state_object.go
  4. 21
      core/state/statedb.go
  5. 4
      core/types/transaction.go
  6. 17
      core/vm/errors.go

120
core/block_cache.go
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
}

Write Preview
Loading…
Cancel
Save