vendor/github.com/hashicorp/yamux/bench_test.go

   1 package yamux
   2
   3 import (
   4         "testing"
   5 )
   6
   7 func BenchmarkPing(b *testing.B) {
   8         client, server := testClientServer()
   9         defer client.Close()
  10         defer server.Close()
  11
  12         for i := 0; i < b.N; i++ {
  13                 rtt, err := client.Ping()
  14                 if err != nil {
  15                         b.Fatalf("err: %v", err)
  16                 }
  17                 if rtt == 0 {
  18                         b.Fatalf("bad: %v", rtt)
  19                 }
  20         }
  21 }
  22
  23 func BenchmarkAccept(b *testing.B) {
  24         client, server := testClientServer()
  25         defer client.Close()
  26         defer server.Close()
  27
  28         go func() {
  29                 for i := 0; i < b.N; i++ {
  30                         stream, err := server.AcceptStream()
  31                         if err != nil {
  32                                 return
  33                         }
  34                         stream.Close()
  35                 }
  36         }()
  37
  38         for i := 0; i < b.N; i++ {
  39                 stream, err := client.Open()
  40                 if err != nil {
  41                         b.Fatalf("err: %v", err)
  42                 }
  43                 stream.Close()
  44         }
  45 }
  46
  47 func BenchmarkSendRecv(b *testing.B) {
  48         client, server := testClientServer()
  49         defer client.Close()
  50         defer server.Close()
  51
  52         sendBuf := make([]byte, 512)
  53         recvBuf := make([]byte, 512)
  54
  55         doneCh := make(chan struct{})
  56         go func() {
  57                 stream, err := server.AcceptStream()
  58                 if err != nil {
  59                         return
  60                 }
  61                 defer stream.Close()
  62                 for i := 0; i < b.N; i++ {
  63                         if _, err := stream.Read(recvBuf); err != nil {
  64                                 b.Fatalf("err: %v", err)
  65                         }
  66                 }
  67                 close(doneCh)
  68         }()
  69
  70         stream, err := client.Open()
  71         if err != nil {
  72                 b.Fatalf("err: %v", err)
  73         }
  74         defer stream.Close()
  75         for i := 0; i < b.N; i++ {
  76                 if _, err := stream.Write(sendBuf); err != nil {
  77                         b.Fatalf("err: %v", err)
  78                 }
  79         }
  80         <-doneCh
  81 }
  82
  83 func BenchmarkSendRecvLarge(b *testing.B) {
  84         client, server := testClientServer()
  85         defer client.Close()
  86         defer server.Close()
  87         const sendSize = 512 * 1024 * 1024
  88         const recvSize = 4 * 1024
  89
  90         sendBuf := make([]byte, sendSize)
  91         recvBuf := make([]byte, recvSize)
  92
  93         b.ResetTimer()
  94         recvDone := make(chan struct{})
  95
  96         go func() {
  97                 stream, err := server.AcceptStream()
  98                 if err != nil {
  99                         return
 100                 }
 101                 defer stream.Close()
 102                 for i := 0; i < b.N; i++ {
 103                         for j := 0; j < sendSize/recvSize; j++ {
 104                                 if _, err := stream.Read(recvBuf); err != nil {
 105                                         b.Fatalf("err: %v", err)
 106                                 }
 107                         }
 108                 }
 109                 close(recvDone)
 110         }()
 111
 112         stream, err := client.Open()
 113         if err != nil {
 114                 b.Fatalf("err: %v", err)
 115         }
 116         defer stream.Close()
 117         for i := 0; i < b.N; i++ {
 118                 if _, err := stream.Write(sendBuf); err != nil {
 119                         b.Fatalf("err: %v", err)
 120                 }
 121         }
 122         <-recvDone
 123 }