gopkg.in/rethinkdb/rethinkdb-go.v6@v6.2.2/internal/integration/tests/benchmarks_test.go (about)

     1  package tests
     2  
     3  import (
     4  	r "gopkg.in/rethinkdb/rethinkdb-go.v6"
     5  	"math/rand"
     6  	"strconv"
     7  	"sync"
     8  	"testing"
     9  	"time"
    10  )
    11  
    12  func BenchmarkConnectionPoolLightweightQuery_Single(b *testing.B) {
    13  	q := r.Random()
    14  
    15  	for i := 0; i < b.N; i++ {
    16  		var num float64
    17  		err := q.ReadOne(&num, session)
    18  		if err != nil {
    19  			b.Errorf("read random number failed: %v", err)
    20  		}
    21  	}
    22  }
    23  
    24  func BenchmarkConnectionPoolLightweightQuery_Parallel(b *testing.B) {
    25  	q := r.Random()
    26  
    27  	b.RunParallel(func(pb *testing.PB) {
    28  		for pb.Next() {
    29  			var num float64
    30  			err := q.ReadOne(&num, session)
    31  			if err != nil {
    32  				b.Errorf("read random number failed: %v", err)
    33  			}
    34  		}
    35  	})
    36  }
    37  
    38  func BenchmarkConnectionPoolLightweightQuery_Parallel3X(b *testing.B) {
    39  	q := r.Random()
    40  
    41  	b.SetParallelism(3)
    42  	b.RunParallel(func(pb *testing.PB) {
    43  		for pb.Next() {
    44  			var num float64
    45  			err := q.ReadOne(&num, session)
    46  			if err != nil {
    47  				b.Errorf("read random number failed: %v", err)
    48  			}
    49  		}
    50  	})
    51  }
    52  
    53  func BenchmarkConnectionPoolLightweightQuery_Parallel10X(b *testing.B) {
    54  	q := r.Random()
    55  
    56  	b.SetParallelism(10)
    57  	b.RunParallel(func(pb *testing.PB) {
    58  		for pb.Next() {
    59  			var num float64
    60  			err := q.ReadOne(&num, session)
    61  			if err != nil {
    62  				b.Errorf("read random number failed: %v", err)
    63  			}
    64  		}
    65  	})
    66  }
    67  
    68  func BenchmarkBatch200RandomWrites(b *testing.B) {
    69  
    70  	var term r.Term
    71  	var data []map[string]interface{}
    72  
    73  	for i := 0; i < b.N; i++ {
    74  
    75  		for is := 0; is < 200; is++ {
    76  			r := rand.New(rand.NewSource(time.Now().UnixNano()))
    77  			cid := map[string]interface{}{
    78  				"customer_id": strconv.FormatInt(r.Int63(), 10),
    79  			}
    80  			data = append(data, cid)
    81  		}
    82  
    83  		// Insert the new item into the database
    84  		term = r.DB("benchmarks").Table("benchmarks").Insert(data)
    85  
    86  		// Insert the new item into the database
    87  		_, err := term.RunWrite(session, r.RunOpts{
    88  			MinBatchRows: 200,
    89  			MaxBatchRows: 200,
    90  		})
    91  		if err != nil {
    92  			b.Errorf("insert failed [%s] ", err)
    93  		}
    94  	}
    95  
    96  }
    97  
    98  func BenchmarkBatch200RandomWritesParallel10(b *testing.B) {
    99  
   100  	var term r.Term
   101  	var data []map[string]interface{}
   102  
   103  	b.SetParallelism(10)
   104  
   105  	b.RunParallel(func(pb *testing.PB) {
   106  
   107  		for pb.Next() {
   108  			for is := 0; is < 200; is++ {
   109  				r := rand.New(rand.NewSource(time.Now().UnixNano()))
   110  				cid := map[string]interface{}{
   111  					"customer_id": strconv.FormatInt(r.Int63(), 10),
   112  				}
   113  				data = append(data, cid)
   114  			}
   115  
   116  			// Insert the new item into the database
   117  			term = r.DB("benchmarks").Table("benchmarks").Insert(data)
   118  
   119  			// Insert the new item into the database
   120  			_, err := term.RunWrite(session, r.RunOpts{
   121  				MinBatchRows: 200,
   122  				MaxBatchRows: 200,
   123  			})
   124  			if err != nil {
   125  				b.Errorf("insert failed [%s] ", err)
   126  			}
   127  		}
   128  	})
   129  
   130  }
   131  
   132  func BenchmarkBatch200SoftRandomWritesParallel10(b *testing.B) {
   133  
   134  	var term r.Term
   135  	var data []map[string]interface{}
   136  
   137  	b.SetParallelism(10)
   138  
   139  	b.RunParallel(func(pb *testing.PB) {
   140  
   141  		for pb.Next() {
   142  
   143  			opts := r.InsertOpts{Durability: "soft"}
   144  
   145  			for is := 0; is < 200; is++ {
   146  				r := rand.New(rand.NewSource(time.Now().UnixNano()))
   147  				cid := map[string]interface{}{
   148  					"customer_id": strconv.FormatInt(r.Int63(), 10),
   149  				}
   150  				data = append(data, cid)
   151  			}
   152  
   153  			// Insert the new item into the database
   154  			term = r.DB("benchmarks").Table("benchmarks").Insert(data, opts)
   155  
   156  			// Insert the new item into the database
   157  			_, err := term.RunWrite(session, r.RunOpts{
   158  				MinBatchRows: 200,
   159  				MaxBatchRows: 200,
   160  			})
   161  			if err != nil {
   162  				b.Errorf("insert failed [%s] ", err)
   163  			}
   164  		}
   165  	})
   166  
   167  }
   168  
   169  func BenchmarkRandomWrites(b *testing.B) {
   170  
   171  	for i := 0; i < b.N; i++ {
   172  		ra := rand.New(rand.NewSource(time.Now().UnixNano()))
   173  		data := map[string]interface{}{
   174  			"customer_id": strconv.FormatInt(ra.Int63(), 10),
   175  		}
   176  		// Insert the new item into the database
   177  		_, err := r.DB("benchmarks").Table("benchmarks").Insert(data).RunWrite(session)
   178  		if err != nil {
   179  			b.Errorf("insert failed [%s] ", err)
   180  		}
   181  	}
   182  
   183  }
   184  
   185  func BenchmarkRandomWritesParallel10(b *testing.B) {
   186  
   187  	// p*GOMAXPROCS
   188  	b.SetParallelism(10)
   189  
   190  	b.RunParallel(func(pb *testing.PB) {
   191  		for pb.Next() {
   192  			ra := rand.New(rand.NewSource(time.Now().UnixNano()))
   193  			data := map[string]interface{}{
   194  				"customer_id": strconv.FormatInt(ra.Int63(), 10),
   195  			}
   196  			// Insert the new item into the database
   197  			_, err := r.DB("benchmarks").Table("benchmarks").Insert(data).RunWrite(session)
   198  			if err != nil {
   199  				b.Errorf("insert failed [%s] ", err)
   200  			}
   201  		}
   202  	})
   203  
   204  }
   205  
   206  func BenchmarkRandomSoftWrites(b *testing.B) {
   207  
   208  	for i := 0; i < b.N; i++ {
   209  		data := map[string]interface{}{
   210  			"customer_id": strconv.FormatInt(rand.Int63(), 10),
   211  		}
   212  		// Insert the new item into the database
   213  		opts := r.InsertOpts{Durability: "soft"}
   214  		_, err := r.DB("benchmarks").Table("benchmarks").Insert(data, opts).RunWrite(session)
   215  		if err != nil {
   216  			b.Errorf("insert failed [%s] ", err)
   217  		}
   218  	}
   219  
   220  }
   221  
   222  func BenchmarkRandomSoftWritesParallel10(b *testing.B) {
   223  
   224  	// p*GOMAXPROCS
   225  	b.SetParallelism(10)
   226  
   227  	b.RunParallel(func(pb *testing.PB) {
   228  		for pb.Next() {
   229  			ra := rand.New(rand.NewSource(time.Now().UnixNano()))
   230  			data := map[string]interface{}{
   231  				"customer_id": strconv.FormatInt(ra.Int63(), 10),
   232  			}
   233  
   234  			// Insert the new item into the database
   235  			opts := r.InsertOpts{Durability: "soft"}
   236  			_, err := r.DB("benchmarks").Table("benchmarks").Insert(data, opts).RunWrite(session)
   237  			if err != nil {
   238  				b.Errorf("insert failed [%s] ", err)
   239  			}
   240  		}
   241  	})
   242  
   243  }
   244  
   245  func BenchmarkSequentialWrites(b *testing.B) {
   246  
   247  	si := 0
   248  	for i := 0; i < b.N; i++ {
   249  		si++
   250  		data := map[string]interface{}{
   251  			"customer_id": si,
   252  		}
   253  
   254  		// Insert the new item into the database
   255  		_, err := r.DB("benchmarks").Table("benchmarks").Insert(data).RunWrite(session)
   256  		if err != nil {
   257  			b.Errorf("insert failed [%s] ", err)
   258  			return
   259  		}
   260  	}
   261  }
   262  
   263  func BenchmarkSequentialWritesParallel10(b *testing.B) {
   264  
   265  	var mu sync.Mutex
   266  	si := 0
   267  
   268  	// p*GOMAXPROCS
   269  	b.SetParallelism(10)
   270  
   271  	b.RunParallel(func(pb *testing.PB) {
   272  		for pb.Next() {
   273  			mu.Lock()
   274  			si++
   275  			mu.Unlock()
   276  
   277  			data := map[string]interface{}{
   278  				"customer_id": si,
   279  			}
   280  
   281  			// Insert the new item into the database
   282  			_, err := r.DB("benchmarks").Table("benchmarks").Insert(data).RunWrite(session)
   283  			if err != nil {
   284  				b.Errorf("insert failed [%s] ", err)
   285  				return
   286  			}
   287  		}
   288  	})
   289  
   290  }
   291  
   292  func BenchmarkSequentialSoftWrites(b *testing.B) {
   293  
   294  	opts := r.InsertOpts{Durability: "soft"}
   295  	si := 0
   296  
   297  	for i := 0; i < b.N; i++ {
   298  		si++
   299  		data := map[string]interface{}{
   300  			"customer_id": si,
   301  		}
   302  
   303  		// Insert the new item into the database
   304  		_, err := r.Table("benchmarks").Insert(data, opts).RunWrite(session)
   305  		if err != nil {
   306  			b.Errorf("insert failed [%s] ", err)
   307  			return
   308  		}
   309  	}
   310  }
   311  
   312  func BenchmarkSequentialSoftWritesParallel10(b *testing.B) {
   313  
   314  	var mu sync.Mutex
   315  	si := 0
   316  
   317  	// p*GOMAXPROCS
   318  	b.SetParallelism(10)
   319  
   320  	b.RunParallel(func(pb *testing.PB) {
   321  		for pb.Next() {
   322  			mu.Lock()
   323  			si++
   324  			mu.Unlock()
   325  
   326  			data := map[string]interface{}{
   327  				"customer_id": si,
   328  			}
   329  
   330  			opts := r.InsertOpts{Durability: "soft"}
   331  
   332  			// Insert the new item into the database
   333  			_, err := r.Table("benchmarks").Insert(data, opts).RunWrite(session)
   334  			if err != nil {
   335  				b.Errorf("insert failed [%s] ", err)
   336  				return
   337  			}
   338  		}
   339  	})
   340  
   341  }