Dagger improvements

dagger.go

@@ -14,7 +14,33 @@ type Dagger struct {
   xn *big.Int
 }
 
+var Found bool
+func (dag *Dagger) Find(obj *big.Int, resChan chan int64) {
+  r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+  for i := 0; i < 1000; i++ {
+    rnd := r.Int63()
+
+    if dag.Eval(big.NewInt(rnd)).Cmp(obj) < 0 {
+      // Post back result on the channel
+      resChan <- rnd
+      // Notify other threads we've found a valid nonce
+      Found = true
+    } else {
+      fmt.Printf(".")
+    }
+
+    // Break out if found
+    if Found { break }
+  }
+
+  resChan <- 0
+}
+
 func (dag *Dagger) Search(diff *big.Int) *big.Int {
+  // TODO fix multi threading. Somehow it results in the wrong nonce
+  amountOfRoutines := 1
+
   dag.hash = big.NewInt(0)
 
   obj := BigPow(2, 256)
@@ -22,23 +48,25 @@ func (dag *Dagger) Search(diff *big.Int) *big.Int {
 
   fmt.Println("diff", diff, "< objective", obj)
 
-  r := rand.New(rand.NewSource(time.Now().UnixNano()))
-  rnd := big.NewInt(r.Int63())
-  fmt.Println("init rnd =", rnd)
+  Found =  false
+  resChan := make(chan int64, 3)
+  var res int64
 
-  for i := 0; i < 1000; i++ {
-    if dag.Eval(rnd).Cmp(obj) < 0 {
-      fmt.Println("Found result! nonce = ", rnd)
+  for k := 0; k < amountOfRoutines; k++ {
+    go dag.Find(obj, resChan)
+  }
 
-      return rnd
-    } else {
-      fmt.Println("Not found :( nonce = ", rnd)
+  // Wait for each go routine to finish
+  for k := 0; k < amountOfRoutines; k++ {
+    // Get the result from the channel. 0 = quit
+    if r := <- resChan; r != 0 {
+      res = r
     }
-
-    rnd = rnd.Add(rnd, big.NewInt(1))
   }
 
-  return big.NewInt(0)
+  fmt.Println("\n")
+
+  return big.NewInt(res)
 }
 
 func DaggerVerify(hash, diff, nonce *big.Int) bool {

dagger_test.go

+package main
+
+import (
+  "testing"
+  "math/big"
+)
+
+func BenchmarkDaggerSearch(b *testing.B) {
+  hash := big.NewInt(0)
+  diff := BigPow(2, 36)
+  o := big.NewInt(0) // nonce doesn't matter. We're only testing against speed, not validity
+
+  // Reset timer so the big generation isn't included in the benchmark
+  b.ResetTimer()
+  // Validate
+  DaggerVerify(hash, diff, o)
+}

ethereum.go

@@ -11,10 +11,10 @@ import (
 
 const Debug = true
 
-var StartDBQueryInterface bool
+var StartConsole bool
 var StartMining bool
 func Init() {
-  flag.BoolVar(&StartDBQueryInterface, "c", false, "console interface")
+  flag.BoolVar(&StartConsole, "c", false, "debug and testing console")
   flag.BoolVar(&StartMining, "mine", false, "start dagger mining")
 
   flag.Parse()
@@ -42,12 +42,13 @@ func main() {
 
   Init()
 
-  if StartDBQueryInterface {
-    dbInterface := NewDBInterface()
-    dbInterface.Start()
+  if StartConsole {
+    console := NewConsole()
+    console.Start()
   } else if StartMining {
     dagger := &Dagger{}
-    dagger.Search(BigPow(2, 36))
+    res := dagger.Search(BigPow(2, 36))
+    fmt.Println("nonce =", res)
   } else {
     fmt.Println("[DBUG]: Starting Ethereum")
     server, err := NewServer()

vm_test.go

 package main
 
+/*
 import (
   _"fmt"
   "testing"
@@ -72,4 +73,4 @@ func TestVm(t *testing.T) {
   bm := NewBlockManager()
   bm.ProcessBlock( block )
 }
-
+*/