first code/readme/license commit

misc/tests/atomic-toy.go

@@ -0,0 +1,22 @@
+package main
+
+import "fmt"
+import "time"
+import "sync/atomic"
+import "runtime"
+
+func main() {
+
+  var ops uint64 = 0
+  for i := 0 ; i < 4 ; i++ {
+    go func () {
+      for {
+        atomic.AddUint64(&ops, 1)
+        runtime.Gosched()
+      }
+    }()
+  }
+  time.Sleep(1*time.Second)
+  opsFinal := atomic.LoadUint64(&ops)
+  fmt.Println("ops:", opsFinal)
+}

misc/tests/bandwidth.go

@@ -0,0 +1,42 @@
+package main
+
+import "fmt"
+import "net"
+import "time"
+
+func main () {
+  addr, err := net.ResolveTCPAddr("tcp", "[::1]:9001")
+  if err != nil { panic(err) }
+  listener, err := net.ListenTCP("tcp", addr)
+  if err != nil { panic(err) }
+  defer listener.Close()
+
+  packetSize := 65535
+  numPackets := 65535
+
+  go func () {
+    send, err := net.DialTCP("tcp", nil, addr)
+    if err != nil { panic(err) }
+    defer send.Close()
+    msg := make([]byte, packetSize)
+    for idx := 0 ; idx < numPackets ; idx++ { send.Write(msg) }
+  }()
+
+  start := time.Now()
+  //msg := make([]byte, 1280)
+  sock, err := listener.AcceptTCP()
+  if err != nil { panic(err) }
+  defer sock.Close()
+  read := 0
+  buf := make([]byte, packetSize)
+  for {
+    n, err := sock.Read(buf)
+    read += n
+    if err != nil { break }
+  }
+  timed := time.Since(start)
+
+  fmt.Printf("%f packets per second\n", float64(numPackets)/timed.Seconds())
+  fmt.Printf("%f bits/sec\n", 8*float64(read)/timed.Seconds())
+}
+

misc/tests/channelbenchmark.go

@@ -0,0 +1,36 @@
+package main
+
+import "time"
+import "fmt"
+import "sync"
+
+func main() {
+  fmt.Println("Testing speed of recv+send loop")
+  const count = 10000000
+  c := make(chan []byte, 1)
+  c<-[]byte{}
+  var wg sync.WaitGroup
+  worker := func () {
+    for idx := 0 ; idx < count ; idx++ {
+      p := <-c
+      select {
+        case c<-p:
+        default:
+      }
+    }
+    wg.Done()
+  }
+  nIter := 0
+  start := time.Now()
+  for idx := 0 ; idx < 1 ; idx++ {
+    go worker()
+    nIter += count
+    wg.Add(1)
+  }
+  wg.Wait()
+  stop := time.Now()
+  timed := stop.Sub(start)
+  fmt.Printf("%d iterations in %s\n", nIter, timed)
+  fmt.Printf("%f iterations per second\n", float64(nIter)/timed.Seconds())
+  fmt.Printf("%s per iteration\n", timed/time.Duration(nIter))
+}

misc/tests/gob-test.go

@@ -0,0 +1,52 @@
+package main
+
+import "bytes"
+import "encoding/gob"
+import "time"
+import "fmt"
+
+type testStruct struct {
+  First uint64
+  Second float64
+  Third []byte
+}
+
+
+func testFunc(tickerDuration time.Duration) {
+  chn := make(chan []byte)
+  ticker := time.NewTicker(tickerDuration)
+  defer ticker.Stop()
+  send := testStruct{First: 1, Second: 2, Third: []byte{3, 4, 5}}
+  buf := bytes.NewBuffer(nil)
+  enc := gob.NewEncoder(buf)
+  dec := gob.NewDecoder(buf)
+  sendCall := func () {
+    err := enc.EncodeValue(&send)
+    if err != nil { panic(err) }
+    bs := make([]byte, buf.Len())
+    buf.Read(bs)
+    fmt.Println("send:", bs)
+    go func() { chn<-bs }()
+  }
+  recvCall := func (bs []byte) {
+    buf.Write(bs)
+    recv := testStruct{}
+    err := dec.DecodeValue(&recv)
+    fmt.Println("recv:", bs)
+    if err != nil { panic(err) }
+  }
+  for {
+    select {
+      case bs := <-chn : recvCall(bs)
+      case <-ticker.C : sendCall()
+    }
+  }
+}
+
+func main() {
+  go testFunc(100*time.Millisecond) // Does not crash
+  time.Sleep(time.Second)
+  go testFunc(time.Nanosecond) // Does crash
+  time.Sleep(time.Second)
+}
+

misc/tests/goroutine-test.go

@@ -0,0 +1,22 @@
+package main
+
+import "sync"
+import "time"
+import "fmt"
+
+func main () {
+  const reqs = 1000000
+  var wg sync.WaitGroup
+  start := time.Now()
+  for idx := 0 ; idx < reqs ; idx++ {
+    wg.Add(1)
+    go func () { wg.Done() } ()
+  }
+  wg.Wait()
+  stop := time.Now()
+  timed := stop.Sub(start)
+  fmt.Printf("%d goroutines in %s (%f per second)\n",
+             reqs,
+             timed,
+             reqs/timed.Seconds())
+}

misc/tests/multicast.go

@@ -0,0 +1,49 @@
+package main
+
+import "fmt"
+import "net"
+import "time"
+
+// TODO look into netmap + libpcap to bypass the kernel as much as possible
+
+func basic_test() {
+
+  // TODO need a way to look up who our link-local neighbors are for each iface!
+  //addr, err := net.ResolveUDPAddr("udp", "[ff02::1%veth0]:9001")
+  addr, err := net.ResolveUDPAddr("udp", "[ff02::1]:9001")
+  if err != nil { panic(err) }
+  sock, err := net.ListenMulticastUDP("udp", nil, addr)
+  if err != nil { panic(err) }
+  defer sock.Close()
+
+  go func () {
+    saddr, err := net.ResolveUDPAddr("udp", "[::]:0")
+    if err != nil { panic(err) }
+    send, err := net.ListenUDP("udp", saddr)
+    if err != nil { panic(err) }
+    defer send.Close()
+    msg := make([]byte, 1280)
+    for {
+      //fmt.Println("Sending...")
+      send.WriteTo(msg, addr)
+    }
+  }()
+
+  numPackets := 1000
+  start := time.Now()
+  msg := make([]byte, 2000)
+  for i := 0 ; i < numPackets ; i++ {
+    //fmt.Println("Reading:", i)
+    sock.ReadFromUDP(msg)
+  }
+  timed := time.Since(start)
+
+  fmt.Printf("%f packets per second\n", float64(numPackets)/timed.Seconds())
+
+}
+
+func main () {
+
+  basic_test()
+
+}

misc/tests/packetbenchmark.go

@@ -0,0 +1,78 @@
+package main
+
+import "fmt"
+import "net"
+import "time"
+
+
+// TODO look into netmap + libpcap to bypass the kernel as much as possible
+
+func basic_test() {
+
+  // TODO need a way to look up who our link-local neighbors are for each iface!
+
+  var ip *net.IP
+  ifaces, err := net.Interfaces()
+  if err != nil { panic(err) }
+  var zone string
+  for _, iface := range ifaces {
+    addrs, err := iface.Addrs()
+    if err != nil { panic(err) }
+    for _, addr := range addrs {
+      addrIP, _, _ := net.ParseCIDR(addr.String())
+      if addrIP.To4() != nil { continue } // IPv6 only
+      if !addrIP.IsLinkLocalUnicast() { continue }
+      zone = iface.Name
+      ip = &addrIP
+    }
+    addrs, err = iface.MulticastAddrs()
+    if err != nil { panic(err) }
+    for _, addr := range addrs {
+      fmt.Println(addr.String())
+    }
+  }
+  if ip == nil { panic("No link-local IPv6 found") }
+  fmt.Println("Using address:", *ip)
+
+  addr := net.UDPAddr{IP: *ip, Port: 9001, Zone: zone}
+
+  saddr := net.UDPAddr{IP: *ip, Port: 9002, Zone: zone}
+  send, err := net.ListenUDP("udp", &saddr)
+  defer send.Close()
+  if err != nil { panic(err) }
+  sock, err := net.ListenUDP("udp", &addr)
+  defer sock.Close()
+  if err != nil { panic(err) }
+
+  const buffSize = 1048576*100
+
+  send.SetWriteBuffer(buffSize)
+  sock.SetReadBuffer(buffSize)
+  sock.SetWriteBuffer(buffSize)
+
+
+  go func () {
+    msg := make([]byte, 1280)
+    for {
+      send.WriteTo(msg, &addr)
+    }
+  }()
+
+  numPackets := 100000
+  start := time.Now()
+  msg := make([]byte, 2000)
+  for i := 0 ; i < numPackets ; i++ {
+    _, addr, _ := sock.ReadFrom(msg)
+    sock.WriteTo(msg, addr)
+  }
+  timed := time.Since(start)
+
+  fmt.Printf("%f packets per second\n", float64(numPackets)/timed.Seconds())
+
+}
+
+func main () {
+
+  basic_test()
+
+}

misc/tests/pool.go

@@ -0,0 +1,83 @@
+package main
+
+import "fmt"
+//import "net"
+import "time"
+import "runtime"
+import "sync/atomic"
+
+func poolbench() {
+  nWorkers := runtime.GOMAXPROCS(0)
+  work := make(chan func(), 1)
+  workers := make(chan chan<- func(), nWorkers)
+  makeWorker := func() chan<- func() {
+    ch := make(chan func())
+    go func() {
+      for {
+        f := <-ch
+        f()
+        select {
+          case workers<-(ch):
+          default: return
+        }
+      }
+    }()
+    return ch
+  }
+  getWorker := func() chan<- func() {
+    select {
+      case ch := <-workers: return ch
+      default: return makeWorker()
+    }
+  }
+  dispatcher := func() {
+    for {
+      w := <-work
+      ch := getWorker()
+      ch<-w
+    }
+  }
+  go dispatcher()
+  var count uint64
+  const nCounts = 1000000
+  for idx := 0 ; idx < nCounts ; idx++ {
+    f := func() { atomic.AddUint64(&count, 1) }
+    work <- f
+  }
+  for atomic.LoadUint64(&count) < nCounts {}
+}
+
+func normalbench() {
+  var count uint64
+  const nCounts = 1000000
+  ch := make(chan struct{}, 1)
+  ch<-struct{}{}
+  for idx := 0 ; idx < nCounts ; idx++ {
+    f := func() { atomic.AddUint64(&count, 1) }
+    f()
+    <-ch
+    ch<-struct{}{}
+  }
+}
+
+func gobench() {
+  var count uint64
+  const nCounts = 1000000
+  for idx := 0 ; idx < nCounts ; idx++ {
+    f := func() { atomic.AddUint64(&count, 1) }
+    go f()
+  }
+  for atomic.LoadUint64(&count) < nCounts {}
+}
+
+func main() {
+  start := time.Now()
+  poolbench()
+  fmt.Println(time.Since(start))
+  start = time.Now()
+  normalbench()
+  fmt.Println(time.Since(start))
+  start = time.Now()
+  gobench()
+  fmt.Println(time.Since(start))
+}

misc/tests/quic.go

@@ -0,0 +1,84 @@
+package main
+
+import (
+  "fmt"
+  "time"
+  "bytes"
+  "sync"
+  "crypto/rand"
+  "crypto/rsa"
+  "crypto/tls"
+  "crypto/x509"
+  "encoding/pem"
+  "math/big"
+  quic "github.com/lucas-clemente/quic-go"
+)
+
+const addr = "[::1]:9001"
+
+func main () {
+  go run_server()
+  run_client()
+}
+
+func run_server() {
+  listener, err := quic.ListenAddr(addr, generateTLSConfig(), nil)
+  if err != nil { panic(err) }
+  ses, err := listener.Accept()
+  if err != nil { panic(err) }
+  for {
+    stream, err := ses.AcceptStream()
+    if err != nil { panic(err) }
+    go func() {
+      defer stream.Close()
+      bs := bytes.Buffer{}
+      _, err := bs.ReadFrom(stream)
+      if err != nil { panic(err) } //<-- TooManyOpenStreams
+    }()
+  }
+}
+
+func run_client() {
+  msgSize := 1048576
+  msgCount := 128
+  ses, err := quic.DialAddr(addr, &tls.Config{InsecureSkipVerify: true}, nil)
+  if err != nil { panic(err) }
+  bs := make([]byte, msgSize)
+  wg := sync.WaitGroup{}
+  start := time.Now()
+  for idx := 0 ; idx < msgCount ; idx++ {
+    wg.Add(1)
+    go func() {
+      defer wg.Done()
+      stream, err := ses.OpenStreamSync()
+      if err != nil { panic(err) }
+      defer stream.Close()
+      stream.Write(bs)
+    }() // "go" this later
+  }
+  wg.Wait()
+  timed := time.Since(start)
+  fmt.Println("Client finished", timed, fmt.Sprintf("%f Bits/sec", 8*float64(msgSize*msgCount)/timed.Seconds()))  
+}
+
+// Setup a bare-bones TLS config for the server
+func generateTLSConfig() *tls.Config {
+	key, err := rsa.GenerateKey(rand.Reader, 1024)
+	if err != nil {
+		panic(err)
+	}
+	template := x509.Certificate{SerialNumber: big.NewInt(1)}
+	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
+	if err != nil {
+		panic(err)
+	}
+	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
+	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})
+
+	tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
+	if err != nil {
+		panic(err)
+	}
+	return &tls.Config{Certificates: []tls.Certificate{tlsCert}}
+}
+

misc/tests/socktest.go

@@ -0,0 +1,69 @@
+package main
+
+import "fmt"
+import "net"
+import "time"
+import "flag"
+import "os"
+import "runtime/pprof"
+
+// TODO look into netmap + libpcap to bypass the kernel as much as possible
+
+func basic_test() {
+
+  // TODO need a way to look up who our link-local neighbors are for each iface!
+
+  addr, err := net.ResolveUDPAddr("udp", "[::1]:9001")
+  if err != nil { panic(err) }
+  sock, err := net.ListenUDP("udp", addr)
+  if err != nil { panic(err) }
+  defer sock.Close()
+
+  go func () {
+    send, err := net.DialUDP("udp", nil, addr)
+    if err != nil { panic(err) }
+    defer send.Close()
+    msg := make([]byte, 1280)
+    for {
+      send.Write(msg)
+    }
+  }()
+
+  numPackets := 1000000
+  start := time.Now()
+  msg := make([]byte, 2000)
+  for i := 0 ; i < numPackets ; i++ {
+    sock.ReadFrom(msg)
+  }
+  timed := time.Since(start)
+
+  fmt.Printf("%f packets per second\n", float64(numPackets)/timed.Seconds())
+
+}
+
+var cpuprofile = flag.String("cpuprofile", "", "write cpu profile `file`")
+var memprofile = flag.String("memprofile", "", "write memory profile to this file")
+
+func main () {
+  flag.Parse()
+  if *cpuprofile != "" {
+      f, err := os.Create(*cpuprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create CPU profile: ", err))
+      }
+      if err := pprof.StartCPUProfile(f); err != nil {
+          panic(fmt.Sprintf("could not start CPU profile: ", err))
+      }
+      defer pprof.StopCPUProfile()
+  }
+  if *memprofile != "" {
+      f, err := os.Create(*memprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create memory profile: ", err))
+      }
+      defer func () { pprof.WriteHeapProfile(f) ; f.Close() }()
+  }
+  basic_test()
+
+}
+

misc/tests/socktest2.go

@@ -0,0 +1,77 @@
+package main
+
+import "fmt"
+import "net"
+import "time"
+import "flag"
+import "os"
+import "runtime/pprof"
+
+// TODO look into netmap + libpcap to bypass the kernel as much as possible
+
+func basic_test() {
+
+  // TODO need a way to look up who our link-local neighbors are for each iface!
+
+  addr, err := net.ResolveUDPAddr("udp", "[::1]:9001")
+  if err != nil { panic(err) }
+  sock, err := net.ListenUDP("udp", addr)
+  if err != nil { panic(err) }
+  defer sock.Close()
+
+  go func () {
+    send, err := net.DialUDP("udp", nil, addr)
+    if err != nil { panic(err) }
+    defer send.Close()
+    msg := make([]byte, 1280)
+    bss := make(net.Buffers, 0, 1024)
+    for {
+      for len(bss) < 1024 {
+        bss = append(bss, msg)
+      }
+      bss.WriteTo(send)
+      //bss = bss[:0]
+      //send.Write(msg)
+    }
+  }()
+
+  numPackets := 1000
+  start := time.Now()
+  msg := make([]byte, 2000)
+  for i := 0 ; i < numPackets ; i++ {
+    n, err := sock.Read(msg)
+    if err != nil { panic(err) }
+    fmt.Println(n)
+  }
+  timed := time.Since(start)
+
+  fmt.Printf("%f packets per second\n", float64(numPackets)/timed.Seconds())
+
+}
+
+var cpuprofile = flag.String("cpuprofile", "", "write cpu profile `file`")
+var memprofile = flag.String("memprofile", "", "write memory profile to this file")
+
+func main () {
+  flag.Parse()
+  if *cpuprofile != "" {
+      f, err := os.Create(*cpuprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create CPU profile: ", err))
+      }
+      if err := pprof.StartCPUProfile(f); err != nil {
+          panic(fmt.Sprintf("could not start CPU profile: ", err))
+      }
+      defer pprof.StopCPUProfile()
+  }
+  if *memprofile != "" {
+      f, err := os.Create(*memprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create memory profile: ", err))
+      }
+      defer func () { pprof.WriteHeapProfile(f) ; f.Close() }()
+  }
+  basic_test()
+
+}
+

misc/tests/socktest_linklocal.go

@@ -0,0 +1,99 @@
+package main
+
+import "flag"
+import "fmt"
+import "net"
+import "os"
+import "runtime/pprof"
+import "time"
+
+// TODO look into netmap + libpcap to bypass the kernel as much as possible
+
+func basic_test() {
+
+  // TODO need a way to look up who our link-local neighbors are for each iface!
+
+  var ip *net.IP
+  ifaces, err := net.Interfaces()
+  if err != nil { panic(err) }
+  var zone string
+  for _, iface := range ifaces {
+    addrs, err := iface.Addrs()
+    if err != nil { panic(err) }
+    for _, addr := range addrs {
+      addrIP, _, _ := net.ParseCIDR(addr.String())
+      if addrIP.To4() != nil { continue } // IPv6 only
+      if !addrIP.IsLinkLocalUnicast() { continue }
+      fmt.Println(iface.Name, addrIP)
+      zone = iface.Name
+      ip = &addrIP
+    }
+    if ip != nil { break }
+    /*
+    addrs, err = iface.MulticastAddrs()
+    if err != nil { panic(err) }
+    for _, addr := range addrs {
+      fmt.Println(addr.String())
+    }
+    */
+  }
+  if ip == nil { panic("No link-local IPv6 found") }
+  fmt.Println("Using address:", *ip)
+  addr := net.UDPAddr{IP: *ip, Port: 9001, Zone: zone}
+
+  laddr, err := net.ResolveUDPAddr("udp", "[::]:9001")
+  if err != nil { panic(err) }
+  sock, err := net.ListenUDP("udp", laddr)
+  if err != nil { panic(err) }
+  defer sock.Close()
+
+  go func () {
+    send, err := net.DialUDP("udp", nil, &addr)
+    //send, err := net.ListenUDP("udp", nil)
+    if err != nil { panic(err) }
+    defer send.Close()
+    msg := make([]byte, 1280)
+    for {
+      send.Write(msg)
+      //send.WriteToUDP(msg, &addr)
+    }
+  }()
+
+  numPackets := 1000000
+  start := time.Now()
+  msg := make([]byte, 2000)
+  for i := 0 ; i < numPackets ; i++ {
+    sock.ReadFromUDP(msg)
+  }
+  timed := time.Since(start)
+
+  fmt.Printf("%f packets per second\n", float64(numPackets)/timed.Seconds())
+
+}
+
+var cpuprofile = flag.String("cpuprofile", "", "write cpu profile `file`")
+var memprofile = flag.String("memprofile", "", "write memory profile to this file")
+
+func main () {
+  flag.Parse()
+  if *cpuprofile != "" {
+      f, err := os.Create(*cpuprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create CPU profile: ", err))
+      }
+      if err := pprof.StartCPUProfile(f); err != nil {
+          panic(fmt.Sprintf("could not start CPU profile: ", err))
+      }
+      defer pprof.StopCPUProfile()
+  }
+  if *memprofile != "" {
+      f, err := os.Create(*memprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create memory profile: ", err))
+      }
+      defer func () { pprof.WriteHeapProfile(f) ; f.Close() }()
+  }
+  basic_test()
+
+}
+

misc/tests/socktest_tcp.go

@@ -0,0 +1,94 @@
+package main
+
+import "fmt"
+import "net"
+import "time"
+import "flag"
+import "os"
+import "runtime/pprof"
+
+// TODO look into netmap + libpcap to bypass the kernel as much as possible?
+
+const buffSize = 32
+
+func basic_test() {
+
+  // TODO need a way to look up who our link-local neighbors are for each iface!
+
+  addr, err := net.ResolveTCPAddr("tcp", "[::1]:9001")
+  if err != nil { panic(err) }
+  listener, err := net.ListenTCP("tcp", addr)
+  if err != nil { panic(err) }
+  defer listener.Close()
+
+  go func () {
+    send, err := net.DialTCP("tcp", nil, addr)
+    if err != nil { panic(err) }
+    defer send.Close()
+    msg := make([]byte, 1280)
+    bss := make(net.Buffers, 0, 1024)
+    for {
+      for len(bss) < 1 { //buffSize {
+        bss = append(bss, msg)
+      }
+      bss := net.Buffers{[]byte{0,1,2,3}, []byte{0,1}, msg}
+      bss.WriteTo(send)
+      //send.Write(msg)
+    }
+  }()
+
+  numPackets := 1000000
+  start := time.Now()
+  //msg := make([]byte, 1280)
+  sock, err := listener.AcceptTCP()
+  if err != nil { panic(err) }
+  defer sock.Close()
+  for i := 0 ; i < numPackets ; i++ {
+    msg := make([]byte, 1280*buffSize)
+    n, err := sock.Read(msg)
+    if err != nil { panic(err) }
+    msg = msg[:n]
+    for len(msg) > 1286 {
+      // handle message
+      i++
+      msg = msg[1286:]
+    }
+    // handle remaining fragment of message
+    //fmt.Println(n)
+  }
+  timed := time.Since(start)
+
+  fmt.Printf("%f packets per second\n", float64(numPackets)/timed.Seconds())
+
+  _ = func (in (chan<- int)) {
+    close(in)
+  }
+
+}
+
+var cpuprofile = flag.String("cpuprofile", "", "write cpu profile `file`")
+var memprofile = flag.String("memprofile", "", "write memory profile to this file")
+
+func main () {
+  flag.Parse()
+  if *cpuprofile != "" {
+      f, err := os.Create(*cpuprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create CPU profile: ", err))
+      }
+      if err := pprof.StartCPUProfile(f); err != nil {
+          panic(fmt.Sprintf("could not start CPU profile: ", err))
+      }
+      defer pprof.StopCPUProfile()
+  }
+  if *memprofile != "" {
+      f, err := os.Create(*memprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create memory profile: ", err))
+      }
+      defer func () { pprof.WriteHeapProfile(f) ; f.Close() }()
+  }
+  basic_test()
+
+}
+

misc/tests/socktest_udp.go

@@ -0,0 +1,72 @@
+package main
+
+import "fmt"
+import "net"
+import "time"
+import "flag"
+import "os"
+import "runtime/pprof"
+
+// TODO look into netmap + libpcap to bypass the kernel as much as possible
+
+func basic_test() {
+
+  // TODO need a way to look up who our link-local neighbors are for each iface!
+
+  addr, err := net.ResolveUDPAddr("udp", "[::1]:0")
+  if err != nil { panic(err) }
+  sock, err := net.ListenUDP("udp", addr)
+  if err != nil { panic(err) }
+  defer sock.Close()
+
+  go func () {
+    raddr := sock.LocalAddr().(*net.UDPAddr)
+    send, err := net.DialUDP("udp", nil, raddr)
+    //send, err := net.ListenUDP("udp", addr)
+    if err != nil { panic(err) }
+    defer send.Close()
+    msg := make([]byte, 1280)
+    for {
+      send.Write(msg)
+      //send.WriteToUDP(msg, raddr)
+    }
+  }()
+
+  numPackets := 1000000
+  start := time.Now()
+  msg := make([]byte, 2000)
+  for i := 0 ; i < numPackets ; i++ {
+    sock.ReadFromUDP(msg)
+  }
+  timed := time.Since(start)
+
+  fmt.Printf("%f packets per second\n", float64(numPackets)/timed.Seconds())
+
+}
+
+var cpuprofile = flag.String("cpuprofile", "", "write cpu profile `file`")
+var memprofile = flag.String("memprofile", "", "write memory profile to this file")
+
+func main () {
+  flag.Parse()
+  if *cpuprofile != "" {
+      f, err := os.Create(*cpuprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create CPU profile: ", err))
+      }
+      if err := pprof.StartCPUProfile(f); err != nil {
+          panic(fmt.Sprintf("could not start CPU profile: ", err))
+      }
+      defer pprof.StopCPUProfile()
+  }
+  if *memprofile != "" {
+      f, err := os.Create(*memprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create memory profile: ", err))
+      }
+      defer func () { pprof.WriteHeapProfile(f) ; f.Close() }()
+  }
+  basic_test()
+
+}
+

misc/tests/socktest_udp2.go

@@ -0,0 +1,72 @@
+package main
+
+import "fmt"
+import "net"
+import "time"
+import "flag"
+import "os"
+import "runtime/pprof"
+
+// TODO look into netmap + libpcap to bypass the kernel as much as possible
+
+func basic_test() {
+
+  // TODO need a way to look up who our link-local neighbors are for each iface!
+
+  saddr, err := net.ResolveUDPAddr("udp", "[::1]:9001")
+  if err != nil { panic(err) }
+  raddr, err := net.ResolveUDPAddr("udp", "[::1]:9002")
+  if err != nil { panic(err) }
+
+  send, err := net.DialUDP("udp", saddr, raddr)
+  if err != nil { panic(err) }
+  defer send.Close()
+
+  recv, err := net.DialUDP("udp", raddr, saddr)
+  if err != nil { panic(err) }
+  defer recv.Close()
+
+  go func () {
+    msg := make([]byte, 1280)
+    for {
+      send.Write(msg)
+    }
+  }()
+
+  numPackets := 1000000
+  start := time.Now()
+  msg := make([]byte, 2000)
+  for i := 0 ; i < numPackets ; i++ {
+    recv.Read(msg)
+  }
+  timed := time.Since(start)
+
+  fmt.Printf("%f packets per second\n", float64(numPackets)/timed.Seconds())
+}
+
+var cpuprofile = flag.String("cpuprofile", "", "write cpu profile `file`")
+var memprofile = flag.String("memprofile", "", "write memory profile to this file")
+
+func main () {
+  flag.Parse()
+  if *cpuprofile != "" {
+      f, err := os.Create(*cpuprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create CPU profile: ", err))
+      }
+      if err := pprof.StartCPUProfile(f); err != nil {
+          panic(fmt.Sprintf("could not start CPU profile: ", err))
+      }
+      defer pprof.StopCPUProfile()
+  }
+  if *memprofile != "" {
+      f, err := os.Create(*memprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create memory profile: ", err))
+      }
+      defer func () { pprof.WriteHeapProfile(f) ; f.Close() }()
+  }
+  basic_test()
+
+}
+

misc/tests/socktest_udp_nodial.go

@@ -0,0 +1,88 @@
+package main
+
+import "fmt"
+import "net"
+import "time"
+import "flag"
+import "os"
+import "runtime/pprof"
+
+// TODO look into netmap + libpcap to bypass the kernel as much as possible
+
+func basic_test() {
+
+  // TODO need a way to look up who our link-local neighbors are for each iface!
+
+  sock, err := net.ListenUDP("udp", nil)
+  if err != nil { panic(err) }
+  defer sock.Close()
+
+  ch := make(chan []byte, 1)
+
+  writer := func () {
+    raddr := sock.LocalAddr().(*net.UDPAddr)
+    //send, err := net.ListenUDP("udp", nil)
+    //if err != nil { panic(err) }
+    //defer send.Close()
+    for {
+      select {
+        case <-ch:
+        default:
+      }
+      msg := make([]byte, 1280)
+      sock.WriteToUDP(msg, raddr)
+      //send.WriteToUDP(msg, raddr)
+    }
+  }
+  go writer()
+  //go writer()
+  //go writer()
+  //go writer()
+
+  numPackets := 65536
+  size := 0
+  start := time.Now()
+  success := 0
+  for i := 0 ; i < numPackets ; i++ {
+    msg := make([]byte, 2048)
+    n, _, err := sock.ReadFromUDP(msg)
+    if err != nil { panic(err) }
+    size += n
+    select {
+      case ch <- msg: success += 1
+      default:
+    }
+  }
+  timed := time.Since(start)
+
+  fmt.Printf("%f packets per second\n", float64(numPackets)/timed.Seconds())
+  fmt.Printf("%f bits per second\n", 8*float64(size)/timed.Seconds())
+  fmt.Println("Success:", success, "/", numPackets)
+}
+
+var cpuprofile = flag.String("cpuprofile", "", "write cpu profile `file`")
+var memprofile = flag.String("memprofile", "", "write memory profile to this file")
+
+func main () {
+  flag.Parse()
+  if *cpuprofile != "" {
+      f, err := os.Create(*cpuprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create CPU profile: ", err))
+      }
+      if err := pprof.StartCPUProfile(f); err != nil {
+          panic(fmt.Sprintf("could not start CPU profile: ", err))
+      }
+      defer pprof.StopCPUProfile()
+  }
+  if *memprofile != "" {
+      f, err := os.Create(*memprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create memory profile: ", err))
+      }
+      defer func () { pprof.WriteHeapProfile(f) ; f.Close() }()
+  }
+  basic_test()
+
+}
+

misc/tests/socktest_udp_sendmmsg.go

@@ -0,0 +1,117 @@
+package main
+
+import "fmt"
+import "net"
+import "time"
+import "flag"
+import "os"
+import "runtime/pprof"
+
+import "golang.org/x/net/ipv6"
+
+// TODO look into netmap + libpcap to bypass the kernel as much as possible
+
+func basic_test() {
+
+  // TODO need a way to look up who our link-local neighbors are for each iface!
+
+  udpAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
+  if err != nil { panic(err) }
+  sock, err := net.ListenUDP("udp", udpAddr)
+  if err != nil { panic(err) }
+  defer sock.Close()
+
+  writer := func () {
+    raddr := sock.LocalAddr().(*net.UDPAddr)
+    send, err := net.ListenUDP("udp", nil)
+    if err != nil { panic(err) }
+    defer send.Close()
+    conn := ipv6.NewPacketConn(send)
+    defer conn.Close()
+    var msgs []ipv6.Message
+    for idx := 0 ; idx < 1024 ; idx++ {
+      msg := ipv6.Message{Addr: raddr, Buffers: [][]byte{make([]byte, 1280)}}
+      msgs = append(msgs, msg)
+    }
+    for {
+      /*
+      var msgs []ipv6.Message
+      for idx := 0 ; idx < 1024 ; idx++ {
+        msg := ipv6.Message{Addr: raddr, Buffers: [][]byte{make([]byte, 1280)}}
+        msgs = append(msgs, msg)
+      }
+      */
+      conn.WriteBatch(msgs, 0)
+    }
+
+  }
+  go writer()
+  //go writer()
+  //go writer()
+  //go writer()
+
+  numPackets := 65536
+  size := 0
+  count := 0
+  start := time.Now()
+  /*
+  conn := ipv6.NewPacketConn(sock)
+  defer conn.Close()
+  for ; count < numPackets ; count++ {
+    msgs := make([]ipv6.Message, 1024)
+    for _, msg := range msgs {
+      msg.Buffers = append(msg.Buffers, make([]byte, 2048))
+    }
+    n, err := conn.ReadBatch(msgs, 0)
+    if err != nil { panic(err) }
+    fmt.Println("DEBUG: n", n)
+    for _, msg := range msgs[:n] {
+      fmt.Println("DEBUG: msg", msg)
+      size += msg.N
+      //for _, bs := range msg.Buffers {
+      //  size += len(bs)
+      //}
+      count++
+    }
+  }
+  //*/
+  //*
+  for ; count < numPackets ; count++ {
+    msg := make([]byte, 2048)
+    n, _, err := sock.ReadFromUDP(msg)
+    if err != nil { panic(err) }
+    size += n
+  }
+  //*/
+  timed := time.Since(start)
+
+  fmt.Printf("%f packets per second\n", float64(count)/timed.Seconds())
+  fmt.Printf("%f bits/second\n", float64(8*size)/timed.Seconds())
+}
+
+var cpuprofile = flag.String("cpuprofile", "", "write cpu profile `file`")
+var memprofile = flag.String("memprofile", "", "write memory profile to this file")
+
+func main () {
+  flag.Parse()
+  if *cpuprofile != "" {
+      f, err := os.Create(*cpuprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create CPU profile: ", err))
+      }
+      if err := pprof.StartCPUProfile(f); err != nil {
+          panic(fmt.Sprintf("could not start CPU profile: ", err))
+      }
+      defer pprof.StopCPUProfile()
+  }
+  if *memprofile != "" {
+      f, err := os.Create(*memprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create memory profile: ", err))
+      }
+      defer func () { pprof.WriteHeapProfile(f) ; f.Close() }()
+  }
+  basic_test()
+
+}
+

misc/tests/tcptest.go

@@ -0,0 +1,96 @@
+package main
+
+import "fmt"
+import "net"
+import "time"
+import "flag"
+import "os"
+import "runtime/pprof"
+
+// TODO look into netmap + libpcap to bypass the kernel as much as possible?
+
+const buffSize = 32
+
+func basic_test() {
+
+  // TODO need a way to look up who our link-local neighbors are for each iface!
+
+  addr, err := net.ResolveTCPAddr("tcp", "[::1]:9001")
+  if err != nil { panic(err) }
+  listener, err := net.ListenTCP("tcp", addr)
+  if err != nil { panic(err) }
+  defer listener.Close()
+
+  go func () {
+    send, err := net.DialTCP("tcp", nil, addr)
+    if err != nil { panic(err) }
+    defer send.Close()
+    msg := make([]byte, 1280)
+    bss := make(net.Buffers, 0, 1024)
+    count := 0
+    for {
+      time.Sleep(100*time.Millisecond)
+      for len(bss) < count {
+        bss = append(bss, msg)
+      }
+      bss.WriteTo(send)
+      count++
+      //send.Write(msg)
+    }
+  }()
+
+  numPackets := 1000000
+  start := time.Now()
+  //msg := make([]byte, 1280)
+  sock, err := listener.AcceptTCP()
+  if err != nil { panic(err) }
+  defer sock.Close()
+  for {
+    msg := make([]byte, 1280*buffSize)
+    n, err := sock.Read(msg)
+    if err != nil { panic(err) }
+    msg = msg[:n]
+    fmt.Println("Read:", n)
+    for len(msg) > 1280 {
+      // handle message
+      msg = msg[1280:]
+    }
+    // handle remaining fragment of message
+    //fmt.Println(n)
+  }
+  timed := time.Since(start)
+
+  fmt.Printf("%f packets per second\n", float64(numPackets)/timed.Seconds())
+
+  _ = func (in (chan<- int)) {
+    close(in)
+  }
+
+}
+
+var cpuprofile = flag.String("cpuprofile", "", "write cpu profile `file`")
+var memprofile = flag.String("memprofile", "", "write memory profile to this file")
+
+func main () {
+  flag.Parse()
+  if *cpuprofile != "" {
+      f, err := os.Create(*cpuprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create CPU profile: ", err))
+      }
+      if err := pprof.StartCPUProfile(f); err != nil {
+          panic(fmt.Sprintf("could not start CPU profile: ", err))
+      }
+      defer pprof.StopCPUProfile()
+  }
+  if *memprofile != "" {
+      f, err := os.Create(*memprofile)
+      if err != nil {
+          panic(fmt.Sprintf("could not create memory profile: ", err))
+      }
+      defer func () { pprof.WriteHeapProfile(f) ; f.Close() }()
+  }
+  basic_test()
+
+}
+

misc/tests/tunbench-client.go

@@ -0,0 +1,82 @@
+package main
+
+import (
+  "fmt"
+	"log"
+  "net"
+  "os/exec"
+  "time"
+
+	"github.com/songgao/water"
+)
+
+const mtu = 65535
+
+func setup_dev() *water.Interface {
+	ifce, err := water.New(water.Config{
+		DeviceType: water.TUN,
+	})
+	if err != nil {
+    panic(err)
+	}
+  return ifce
+}
+
+func setup_dev1() *water.Interface {
+  ifce := setup_dev()
+  cmd := exec.Command("ip", "-f", "inet6",
+                      "addr", "add", "fc00::2/8",
+                      "dev", ifce.Name())
+  out, err := cmd.CombinedOutput()
+  if err != nil {
+    fmt.Println(string(out))
+    panic("Failed to assign address")
+  }
+  cmd = exec.Command("ip", "link", "set",
+                     "dev", ifce.Name(),
+                     "mtu", fmt.Sprintf("%d", mtu),
+                     "up")
+  out, err = cmd.CombinedOutput()
+  if err != nil {
+    fmt.Println(string(out))
+    panic("Failed to bring up interface")
+  }
+  return ifce
+}
+
+func connect(ifce *water.Interface) {
+  conn, err := net.DialTimeout("tcp", "192.168.2.2:9001", time.Second)
+  if err != nil { panic(err) }
+  sock := conn.(*net.TCPConn)
+  // TODO go a worker to move packets to/from the tun
+}
+
+func bench() {
+}
+
+func main() {
+  ifce := setup_dev1()
+  connect(ifce)
+  bench()
+  fmt.Println("Done?")
+  return
+	ifce, err := water.New(water.Config{
+		DeviceType: water.TUN,
+	})
+	if err != nil {
+    panic(err)
+	}
+
+	log.Printf("Interface Name: %s\n", ifce.Name())
+
+	packet := make([]byte, 2000)
+	for {
+		n, err := ifce.Read(packet)
+		if err != nil {
+      panic(err)
+			log.Fatal(err)
+		}
+		log.Printf("Packet Received: % x\n", packet[:n])
+	}
+}
+

misc/tests/tunbench-server.go

@@ -0,0 +1,127 @@
+package main
+
+import (
+  "fmt"
+	"log"
+  "net"
+  "os/exec"
+
+	"github.com/songgao/water"
+)
+
+const mtu = 65535
+const netnsName = "tunbenchns"
+
+func setup_dev() *water.Interface {
+	ifce, err := water.New(water.Config{
+		DeviceType: water.TUN,
+	})
+	if err != nil {
+    panic(err)
+	}
+  return ifce
+}
+
+func setup_dev1() *water.Interface {
+  ifce := setup_dev()
+  cmd := exec.Command("ip", "-f", "inet6",
+                      "addr", "add", "fc00::1/8",
+                      "dev", ifce.Name())
+  out, err := cmd.CombinedOutput()
+  if err != nil {
+    fmt.Println(string(out))
+    fmt.Println(string(err))
+    panic("Failed to assign address")
+  }
+  cmd = exec.Command("ip", "link", "set",
+                     "dev", tun.name,
+                     "mtu", fmt.Sprintf("%d", mtu),
+                     "up")
+  out, err = cmd.CombinedOutput()
+  if err != nil {
+    fmt.Println(string(out))
+    panic("Failed to bring up interface")
+  }
+  return ifce
+}
+
+func addNS(name string) {
+  cmd := exec.COmmand("ip", "netns", "add", name)
+  out, err := cmd.CombinedOutput()
+  if err != nil {
+    fmt.Println(string(out))
+    panic("Failed to setup netns")
+  }
+}
+
+func delNS(name string) {
+  cmd := exec.COmmand("ip", "netns", "delete", name)
+  out, err := cmd.CombinedOutput()
+  if err != nil {
+    fmt.Println(string(out))
+    panic("Failed to setup netns")
+  }
+}
+
+func doInNetNS(comm ...string) *exec.Cmd {
+  return exec.Command("ip", "netns", "exec", netnsName, comm...)
+}
+
+func setup_dev2() *water.Interface {
+  ifce := setup_dev()
+  addNS(netnsName)
+  cmd := exec.Command("ip", "link", "set", ifce.Name(), "netns", netnsName)
+  out, err := cmd.CombinedOutput()
+  if err != nil {
+    fmt.Println(string(out))
+    panic("Failed to move tun to netns")
+  }
+  cmd = doInNetNS("ip", "-f", "inet6",
+                  "addr", "add", "fc00::2/8",
+                  "dev", ifce.Name())
+  out, err = cmd.CombinedOutput()
+  if err != nil {
+    fmt.Println(string(out))
+    panic("Failed to assign address")
+  }
+  cmd = doInNetNS("ip", "link", "set",
+                  "dev", tun.name,
+                  "mtu", fmt.Sprintf("%d", mtu),
+                  "up")
+  out, err := cmd.CombinedOutput()
+  if err != nil {
+    fmt.Println(string(out))
+    fmt.Println(string(err))
+    panic("Failed to bring up interface")
+  }
+  return ifce
+}
+
+func connect() {
+
+}
+
+func bench() {
+}
+
+func main() {
+	ifce, err := water.New(water.Config{
+		DeviceType: water.TUN,
+	})
+	if err != nil {
+    panic(err)
+	}
+
+	log.Printf("Interface Name: %s\n", ifce.Name())
+
+	packet := make([]byte, 2000)
+	for {
+		n, err := ifce.Read(packet)
+		if err != nil {
+      panic(err)
+			log.Fatal(err)
+		}
+		log.Printf("Packet Received: % x\n", packet[:n])
+	}
+}
+

misc/tests/tunbench.go

@@ -0,0 +1,130 @@
+package main
+
+import (
+  "fmt"
+	"log"
+  "net"
+  "os/exec"
+
+	"github.com/songgao/water"
+)
+
+const mtu = 65535
+const netnsName = "tunbenchns"
+
+func setup_dev() *water.Interface {
+	ifce, err := water.New(water.Config{
+		DeviceType: water.TUN,
+	})
+	if err != nil {
+    panic(err)
+	}
+  return ifce
+}
+
+func setup_dev1() *water.Interface {
+  ifce := setup_dev()
+  cmd := exec.Command("ip", "-f", "inet6",
+                      "addr", "add", "fc00::1/8",
+                      "dev", ifce.Name())
+  out, err := cmd.CombinedOutput()
+  if err != nil {
+    fmt.Println(string(out))
+    fmt.Println(string(err))
+    panic("Failed to assign address")
+  }
+  cmd = exec.Command("ip", "link", "set",
+                     "dev", tun.name,
+                     "mtu", fmt.Sprintf("%d", mtu),
+                     "up")
+  out, err = cmd.CombinedOutput()
+  if err != nil {
+    fmt.Println(string(out))
+    panic("Failed to bring up interface")
+  }
+  return ifce
+}
+
+func addNS(name string) {
+  cmd := exec.COmmand("ip", "netns", "add", name)
+  out, err := cmd.CombinedOutput()
+  if err != nil {
+    fmt.Println(string(out))
+    panic("Failed to setup netns")
+  }
+}
+
+func delNS(name string) {
+  cmd := exec.COmmand("ip", "netns", "delete", name)
+  out, err := cmd.CombinedOutput()
+  if err != nil {
+    fmt.Println(string(out))
+    panic("Failed to setup netns")
+  }
+}
+
+func doInNetNS(comm ...string) *exec.Cmd {
+  return exec.Command("ip", "netns", "exec", netnsName, comm...)
+}
+
+func setup_dev2() *water.Interface {
+  ifce := setup_dev()
+  addNS(netnsName)
+  cmd := exec.Command("ip", "link", "set", ifce.Name(), "netns", netnsName)
+  out, err := cmd.CombinedOutput()
+  if err != nil {
+    fmt.Println(string(out))
+    panic("Failed to move tun to netns")
+  }
+  cmd = 
+  cmd = exec.Command(
+                      "ip", "-f", "inet6",
+                      "addr", "add", "fc00::2/8",
+                      "dev", ifce.Name())
+  out, err := cmd.CombinedOutput()
+  if err != nil {
+    fmt.Println(string(out))
+    panic("Failed to assign address")
+  }
+  cmd = exec.Command(
+                      "ip", "link", "set",
+                     "dev", tun.name,
+                     "mtu", fmt.Sprintf("%d", mtu),
+                     "up")
+  out, err := cmd.CombinedOutput()
+  if err != nil {
+    fmt.Println(string(out))
+    fmt.Println(string(err))
+    panic("Failed to bring up interface")
+  }
+  return ifce
+}
+
+func connect() {
+
+}
+
+func bench() {
+}
+
+func main() {
+	ifce, err := water.New(water.Config{
+		DeviceType: water.TUN,
+	})
+	if err != nil {
+    panic(err)
+	}
+
+	log.Printf("Interface Name: %s\n", ifce.Name())
+
+	packet := make([]byte, 2000)
+	for {
+		n, err := ifce.Read(packet)
+		if err != nil {
+      panic(err)
+			log.Fatal(err)
+		}
+		log.Printf("Packet Received: % x\n", packet[:n])
+	}
+}
+

misc/tests/tuntest.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"log"
+	"net"
+	"sync"
+
+	"github.com/FlexibleBroadband/tun-go"
+)
+
+// first start server tun server.
+func main() {
+	wg := sync.WaitGroup{}
+	// local tun interface read and write channel.
+	rCh := make(chan []byte, 1024)
+	// read from local tun interface channel, and write into remote udp channel.
+	wg.Add(1)
+	go func() {
+		wg.Done()
+		for {
+			data := <-rCh
+			// if data[0]&0xf0 == 0x40
+			// write into udp conn.
+			log.Println("tun->conn:", len(data))
+			log.Println("read!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+			log.Println("src:", net.IP(data[8:24]), "dst:", net.IP(data[24:40]))
+		}
+	}()
+
+  address := net.ParseIP("fc00::1")
+	tuntap, err := tun.OpenTun(address)
+	if err != nil { panic(err) }
+	defer tuntap.Close()
+	// read data from tun into rCh channel.
+	wg.Add(1)
+	go func() {
+		if err := tuntap.Read(rCh); err != nil { panic(err) }
+		wg.Done()
+	}()
+	wg.Wait()
+}

misc/tests/wire-test.go

@@ -0,0 +1,39 @@
+package main
+
+import "wire"
+import "fmt"
+
+import "time"
+
+func main() {
+  for idx := 0 ; idx < 64 ; idx++ {
+    num := uint64(1) << uint(idx)
+    encoded := make([]byte, 10)
+    length := wire.Encode_uint64(num, encoded)
+    decoded, _ := wire.Decode_uint64(encoded[:length])
+    if decoded != num { panic(fmt.Sprintf("%d != %d", decoded, num)) }
+  }
+  const count = 1000000
+  start := time.Now()
+  encoded := make([]byte, 10)
+  //num := ^uint64(0) // Longest possible value for full uint64 range
+  num := ^uint64(0) >> 1 // Largest positive int64 (real use case)
+  //num := uint64(0) // Shortest possible value, most will be of this length
+  length := wire.Encode_uint64(num, encoded)
+  for idx := 0 ; idx < count ; idx++ {
+    wire.Encode_uint64(num, encoded)
+  }
+  timed := time.Since(start)
+  fmt.Println("Ops:", count/timed.Seconds())
+  fmt.Println("Time:", timed.Nanoseconds()/count)
+
+  encoded = encoded[:length]
+  start = time.Now()
+  for idx := 0 ; idx < count ; idx++ {
+    wire.Decode_uint64(encoded)
+  }
+  timed = time.Since(start)
+  fmt.Println("Ops:", count/timed.Seconds())
+  fmt.Println("Time:", timed.Nanoseconds()/count)
+}
+