test: add benchmark tests

Added benchmarks of large Select and Replace.
Added a new target in Makefile for running benchmark tests.
Added a new space in config.lua for large Select tests.
Added a new target in Makefile for measuring performance
degradation between current changes and master.
Added a new line in gitignore for ignoring artifacts from bench target.

Added a new step for running benchmark tests in ci.

Added description to the CONTRIBUTING.md for how to
run benchmark tests.

Closes #122

Author: vr009

.github/workflows/testing.yml

@@ -63,3 +63,6 @@ jobs:
           COVERALLS_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           make coveralls
+
+      - name: Check workability of benchmark tests
+        run: make bench-deps bench DURATION=1x COUNT=1

.gitignore

@@ -3,3 +3,4 @@
 .idea/
 work_dir*
 .rocks
+bench

CONTRIBUTING.md

@@ -38,6 +38,43 @@ For example, for running tests in `multi`, `uuid` and `main` packages, call
 make test-multi test-uuid test-main
 ```
 
+Before running benchmark or measuring performance degradation, install benchmark dependencies:
+```bash
+make bench-deps BENCH_PATH=custom_path
+```
+
+Use the variable `BENCH_PATH` to specialize the path of benchmark artifacts.
+It is set to `bench` by default.
+
+To run benchmark tests, call:
+```bash
+make bench DURATION=5s COUNT=7 BENCH_PATH=custom_path TEST_PATH=.
+```
+
+Use the variable `DURATION` to set the duration of perf tests. That variable is mapped on
+testing [flag](https://pkg.go.dev/cmd/go#hdr-Testing_flags) `-benchtime` for gotest.
+It may take the values in seconds (e.g, `5s`) or count of iterations (e.g, `1000x`).
+It is set to `3s` by default.
+
+Use the variable `COUNT` to control the count of benchmark runs for each test. It is set to `5` by default.
+That variable is mapped on testing flag `-count`.
+Use higher values if the benchmark numbers aren't stable.
+
+Use the variable `TEST_PATH` to set the directory of test files.
+It is set to `./...` by default, so it runs all the Benchmark tests in project.
+
+Before calculating performance difference between master and the current branch, 
+prepare benchmark results of master:
+```bash
+make perf-reference DURATION=5s COUNT=7 BENCH_PATH=custom_path TEST_PATH=.
+```
+
+To measure performance degradation after changes in code, firstly call `make bench`
+and `perf-reference` and then run:
+```bash
+make perf-diff BENCH_PATH=custom_path
+```
+
 ## Code review checklist
 
 - Public API contains functions, variables, constants that are needed from

Makefile

@@ -55,3 +55,33 @@ coverage:
 coveralls: coverage
 	go get github.com/mattn/goveralls
 	goveralls -coverprofile=$(COVERAGE_FILE) -service=github
+
+DURATION ?= 3s
+COUNT ?= 5
+BENCH_PATH ?= bench
+TEST_PATH ?= ./...
+
+.PHONY: bench-deps
+bench-deps:
+	rm -rf ${BENCH_PATH}
+	mkdir ${BENCH_PATH}
+	go clean -testcache
+	cd ${BENCH_PATH} && git clone https://go.googlesource.com/perf && cd perf && go install ./cmd/benchstat
+	rm -rf ${BENCH_PATH}/perf
+
+.PHONY: bench
+bench:
+	go test ${TEST_PATH} -bench=. -run=^Benchmark -benchmem -benchtime=${DURATION} -count=${COUNT} 2>&1 \
+		| grep -v pkg: | grep -v ok | grep -v ? | tee ${BENCH_PATH}/bench.txt
+	benchstat ${BENCH_PATH}/bench.txt
+
+.PHONY: perf-reference
+perf-reference:
+	cd ${BENCH_PATH} && git clone https://github.com/tarantool/go-tarantool.git
+	cd ${BENCH_PATH}/go-tarantool && go test ${TESTS_PATH} -bench=. -run=^Benchmark -benchmem -benchtime=${DURATION} \
+ 		-count=${COUNT} 2>&1 | grep -v pkg: | grep -v ok | grep -v ? | tee ../reference.txt
+	rm -rf ${BENCH_PATH}/go-tarantool
+
+.PHONY: perf-diff
+perf-diff:
+	benchstat ${BENCH_PATH}/reference.txt ${BENCH_PATH}/bench.txt

config.lua

@@ -40,6 +40,31 @@ box.once("init", function()
     })
     st:truncate()
 
+    local s2 = box.schema.space.create('test_perf', {
+        id = 520,
+        temporary = true,
+        if_not_exists = true,
+        field_count = 3,
+        format = {
+            {name = "id", type = "unsigned"},
+            {name = "name", type = "string"},
+            {name = "arr1", type = "array"},
+        },
+    })
+    s2:create_index('primary', {type = 'tree', unique = true, parts = {1, 'unsigned'}, if_not_exists = true})
+    s2:create_index('secondary', {id = 5, type = 'tree', unique = false, parts = {2, 'string'}, if_not_exists = true})
+    local arr_data = {}
+    for i = 1,100 do
+        arr_data[i] = i
+    end
+    for i = 1,1000 do
+        s2:insert{
+            i,
+            'test_name',
+            arr_data,
+        }
+    end
+
     --box.schema.user.grant('guest', 'read,write,execute', 'universe')
     box.schema.func.create('box.info')
     box.schema.func.create('simple_incr')
@@ -49,6 +74,7 @@ box.once("init", function()
     box.schema.user.grant('test', 'execute', 'universe')
     box.schema.user.grant('test', 'read,write', 'space', 'test')
     box.schema.user.grant('test', 'read,write', 'space', 'schematest')
+    box.schema.user.grant('test', 'read,write', 'space', 'test_perf')
 end)
 
 local function func_name()

tarantool_test.go

@@ -363,6 +363,57 @@ func BenchmarkClientParallelMassiveUntyped(b *testing.B) {
 	close(limit)
 }
 
+func BenchmarkConnection_Replace(b *testing.B) {
+	conn, err := Connect(server, opts)
+	if err != nil {
+		b.Errorf("No connection available")
+		return
+	}
+	defer conn.Close()
+	spaceNo = 520
+
+	rSpaceNo, _, err := conn.Schema.ResolveSpaceIndex("test_perf", "secondary")
+	if err != nil {
+		b.Fatalf("Space is not resolved: %s", err.Error())
+	}
+
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_, err := conn.Replace(rSpaceNo, []interface{}{uint(1), "hello", []interface{}{}})
+			if err != nil {
+				b.Error(err)
+			}
+		}
+	})
+}
+
+func BenchmarkConnection_LargeSelect(b *testing.B) {
+	conn, err := Connect(server, opts)
+	if err != nil {
+		b.Errorf("No connection available")
+		return
+	}
+	defer conn.Close()
+
+	schema := conn.Schema
+	rSpaceNo, rIndexNo, err := schema.ResolveSpaceIndex("test_perf", "secondary")
+	if err != nil {
+		b.Fatalf("symbolic space and index params not resolved")
+	}
+
+	offset, limit := uint32(0), uint32(1000)
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_, err := conn.Select(rSpaceNo, rIndexNo, offset, limit, IterEq, []interface{}{"test_name"})
+			if err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
+
 ///////////////////
 
 func TestClient(t *testing.T) {