SHARE
TWEET

Untitled

a guest Jun 4th, 2017 56 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. package main
  2.  
  3. import (
  4.     "context"
  5.     "database/sql"
  6.     "flag"
  7.     "fmt"
  8.     "log"
  9.     "os"
  10.     "runtime"
  11.     "sync"
  12.     "sync/atomic"
  13.     "time"
  14.  
  15.     "github.com/kayac/parallel-benchmark/benchmark"
  16.     "github.com/shogo82148/mysql"
  17. )
  18.  
  19. var mu sync.Mutex
  20. var errCount map[string]int
  21.  
  22. type logger struct {
  23. }
  24.  
  25. func (logger) Print(v ...interface{}) {
  26.     s := fmt.Sprint(v...)
  27.     mu.Lock()
  28.     if errCount == nil {
  29.         errCount = map[string]int{}
  30.     }
  31.     errCount[s] = errCount[s] + 1
  32.     mu.Unlock()
  33. }
  34.  
  35. var value atomic.Value
  36.  
  37. func main() {
  38.     var p int
  39.     flag.IntVar(&p, "p", 1, "parallelism")
  40.     var d time.Duration
  41.     flag.DurationVar(&d, "d", 10*time.Second, "duration")
  42.     flag.Parse()
  43.  
  44.     mysql.SetLogger(logger{})
  45.  
  46.     user := os.Getenv("MYSQL_TEST_USER")
  47.     pass := os.Getenv("MYSQL_TEST_PASS")
  48.     addr := os.Getenv("MYSQL_TEST_ADDR")
  49.     dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?timeout=30s&strict=true", user, pass, addr, "gotest")
  50.     db, err := sql.Open("mysql", dsn)
  51.     if err != nil {
  52.         panic(err)
  53.     }
  54.     db.SetMaxIdleConns(p * runtime.GOMAXPROCS(0))
  55.  
  56.     go canceler()
  57.     time.Sleep(100 * time.Millisecond)
  58.  
  59.     benchmark.RunFunc(
  60.         func() int {
  61.             score := 1
  62.             ctx := value.Load().(context.Context)
  63.             if err := db.PingContext(ctx); err != nil {
  64.                 logger{}.Print("conn.PingContext: ", err)
  65.                 score = 0
  66.             }
  67.             if _, err := db.ExecContext(ctx, "DO ?", 1); err != nil {
  68.                 logger{}.Print("conn.ExecContext: ", err)
  69.                 score = 0
  70.             }
  71.             var v int
  72.             row := db.QueryRowContext(ctx, "SELECT ?", 1)
  73.             if err := row.Scan(&v); err != nil {
  74.                 logger{}.Print("conn.Scan: ", err)
  75.                 score = 0
  76.             }
  77.  
  78.             stmt, err := db.PrepareContext(ctx, "DO ?")
  79.             if err != nil {
  80.                 logger{}.Print("conn.PrepareContext: ", err)
  81.                 score = 0
  82.             } else {
  83.                 defer stmt.Close()
  84.                 if _, err := stmt.ExecContext(ctx, 1); err != nil {
  85.                     logger{}.Print("stmt.ExecContext: ", err)
  86.                     score = 0
  87.                 }
  88.             }
  89.  
  90.             stmt, err = db.PrepareContext(ctx, "SELECT ?")
  91.             if err != nil {
  92.                 logger{}.Print("conn.PrepareContext: ", err)
  93.                 score = 0
  94.             } else {
  95.                 defer stmt.Close()
  96.                 row := stmt.QueryRowContext(ctx, 1)
  97.                 if err := row.Scan(&v); err != nil {
  98.                     logger{}.Print("stmt.Scan: ", err)
  99.                     score = 0
  100.                 }
  101.             }
  102.  
  103.             tx, err := db.BeginTx(ctx, nil)
  104.             if err != nil {
  105.                 logger{}.Print("conn.BeginContext: ", err)
  106.                 score = 0
  107.             } else {
  108.                 if _, err := tx.ExecContext(ctx, "DO ?", 1); err != nil {
  109.                     logger{}.Print("tx.ExecContext: ", err)
  110.                     score = 0
  111.                 }
  112.                 if err := tx.Commit(); err != nil {
  113.                     logger{}.Print("tx.Commit: ", err)
  114.                     score = 0
  115.                 }
  116.             }
  117.  
  118.             return score
  119.         },
  120.         d,
  121.         p,
  122.     )
  123.  
  124.     for err, count := range errCount {
  125.         log.Println(err, count)
  126.     }
  127. }
  128.  
  129. func canceler() {
  130.     for {
  131.         ctx, cancel := context.WithCancel(context.Background())
  132.         value.Store(ctx)
  133.         time.Sleep(100 * time.Millisecond)
  134.         cancel()
  135.     }
  136. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top