first code/readme/license commit

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()
+
+}
+