Refactored VM to two separate VMs; std & debug

Standard VM should be about 10x faster than the debug VM. Some error
checking has been removed, all of the log statements and therefor quite
some unnecessary if-statements.

ethvm/vm_test.go

@@ -2,9 +2,9 @@ package ethvm
 
 import (
 	"fmt"
+	"io/ioutil"
 	"log"
 	"math/big"
-	"os"
 	"testing"
 
 	"github.com/ethereum/eth-go/ethlog"
@@ -17,6 +17,7 @@ type TestEnv struct {
 
 func (self TestEnv) Origin() []byte         { return nil }
 func (self TestEnv) BlockNumber() *big.Int  { return nil }
+func (self TestEnv) BlockHash() []byte      { return nil }
 func (self TestEnv) PrevHash() []byte       { return nil }
 func (self TestEnv) Coinbase() []byte       { return nil }
 func (self TestEnv) Time() int64            { return 0 }
@@ -24,20 +25,65 @@ func (self TestEnv) Difficulty() *big.Int   { return nil }
 func (self TestEnv) Value() *big.Int        { return nil }
 func (self TestEnv) State() *ethstate.State { return nil }
 
-func TestVm(t *testing.T) {
-	ethlog.AddLogSystem(ethlog.NewStdLogSystem(os.Stdout, log.LstdFlags, ethlog.LogLevel(4)))
+func setup(level int, typ Type) (*Closure, VirtualMachine) {
+	// Pipe output to /dev/null
+	ethlog.AddLogSystem(ethlog.NewStdLogSystem(ioutil.Discard, log.LstdFlags, ethlog.LogLevel(level)))
 
 	ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
 
 	stateObject := ethstate.NewStateObject([]byte{'j', 'e', 'f', 'f'})
-	callerClosure := NewClosure(stateObject, stateObject, []byte{0x60, 0x01}, big.NewInt(1000000), big.NewInt(0))
+	callerClosure := NewClosure(nil, stateObject, stateObject, []byte{
+		PUSH1, 1,
+		PUSH1, 0,
+		MSTORE,
+		PUSH1, 32,
+		PUSH1, 0,
+		RETURN,
+	}, big.NewInt(1000000), big.NewInt(0))
 
-	vm := New(TestEnv{})
-	vm.Verbose = true
+	return callerClosure, New(TestEnv{}, typ)
+}
 
-	ret, _, e := callerClosure.Call(vm, nil)
+func TestDebugVm(t *testing.T) {
+	closure, vm := setup(4, DebugVmTy)
+	ret, _, e := closure.Call(vm, nil)
 	if e != nil {
 		fmt.Println("error", e)
 	}
-	fmt.Println(ret)
+
+	if ret[len(ret)-1] != 1 {
+		t.Errorf("Expected VM to return 1, got", ret, "instead.")
+	}
+}
+
+func TestVm(t *testing.T) {
+	closure, vm := setup(4, StandardVmTy)
+	ret, _, e := closure.Call(vm, nil)
+	if e != nil {
+		fmt.Println("error", e)
+	}
+
+	if ret[len(ret)-1] != 1 {
+		t.Errorf("Expected VM to return 1, got", ret, "instead.")
+	}
+}
+
+func BenchmarkDebugVm(b *testing.B) {
+	closure, vm := setup(3, DebugVmTy)
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		closure.Call(vm, nil)
+	}
+}
+
+func BenchmarkVm(b *testing.B) {
+	closure, vm := setup(3, StandardVmTy)
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		closure.Call(vm, nil)
+	}
 }