roachtest: add buffered-writes variants of TPCC bench

This commit adds the following variants of TPCC bench:
- write buffering enabled, pipelining enabled (by default),
- write buffering enabled, pipelining disabled.

The former will help us compare the performance of buffered writes to
the default setup, and the latter will inform our decision to replace
pipelining with buffering altogether.

Part of: #148235
Release note: None

Author: miraradeva

pkg/cmd/roachtest/registry/test_spec.go

@@ -131,6 +131,12 @@ type TestSpec struct {
 	// to epoch leases.
 	Leases LeaseType
 
+	// WriteOptimization specifies what kind of write optimization to use.
+	// Defaults to pipelining. This is currently used only in benchmark tests.
+	// If used in a non-benchmark test, this setting will be overwritten to enable
+	// pipelining and additionally, with 50% probability, buffering.
+	WriteOptimization WriteOptimizationType
+
 	// SkipPostValidations is a bit-set of post-validations that should be skipped
 	// after the test completes. This is useful for tests that are known to be
 	// incompatible with some validations. By default, tests will run all
@@ -284,6 +290,35 @@ const (
 // The list does not contain aliases like "default" and "metamorphic".
 var LeaseTypes = []LeaseType{EpochLeases, ExpirationLeases, LeaderLeases}
 
+// WriteOptimizationType specifies the type of write optimization to use.
+type WriteOptimizationType int
+
+func (w WriteOptimizationType) String() string {
+	switch w {
+	case DefaultWriteOptimization:
+		return "default"
+	case Pipelining:
+		return "pipelining"
+	case Buffering:
+		return "buffering"
+	case PipeliningBuffering:
+		return "pipelining-buffering"
+	default:
+		return fmt.Sprintf("writeoptimization-%d", w)
+	}
+}
+
+const (
+	// DefaultWriteOptimization uses the default cluster settings.
+	DefaultWriteOptimization = WriteOptimizationType(iota)
+	// Pipelining uses write pipelining.
+	Pipelining
+	// Buffering uses client-side write buffering.
+	Buffering
+	// PipeliningBuffering uses both buffering and pipelining.
+	PipeliningBuffering
+)
+
 // CloudSet represents a set of clouds.
 //
 // Instances of CloudSet are immutable. The uninitialized (zero) value is not

pkg/cmd/roachtest/test_runner.go

@@ -933,6 +933,22 @@ func (r *testRunner) runWorker(
 					t.Fatalf("unknown lease type %s", leases)
 				}
 
+				// Choose which write optimization to use. These are currently used only
+				// in benchmark tests. For non-benchmark tests, write buffering will be
+				// enabled metamorphically below.
+				switch testSpec.WriteOptimization {
+				case registry.DefaultWriteOptimization:
+				case registry.Pipelining:
+					c.clusterSettings["kv.transaction.write_pipelining.enabled"] = "true"
+					c.clusterSettings["kv.transaction.write_buffering.enabled"] = "false"
+				case registry.Buffering:
+					c.clusterSettings["kv.transaction.write_buffering.enabled"] = "true"
+					c.clusterSettings["kv.transaction.write_pipelining.enabled"] = "false"
+				case registry.PipeliningBuffering:
+					c.clusterSettings["kv.transaction.write_pipelining.enabled"] = "true"
+					c.clusterSettings["kv.transaction.write_buffering.enabled"] = "true"
+				}
+
 				// Apply metamorphic settings not explicitly defined by the test.
 				// These settings should only be applied to non-benchmark tests.
 				if !testSpec.Benchmark {

pkg/cmd/roachtest/tests/tpcc.go

@@ -1619,6 +1619,50 @@ func registerTPCC(r registry.Registry) {
 		Clouds: registry.OnlyGCE,
 		Suites: registry.Suites(registry.Weekly),
 	})
+
+	// Buffered writes benchmarks. These are duplicates of variants above.
+
+	// A variant with only buffering enabled (pipelining disabled).
+	registerTPCCBenchSpec(
+		r, tpccBenchSpec{
+			Nodes: 3,
+			CPUs:  16,
+
+			LoadWarehousesGCE:   3500,
+			LoadWarehousesAWS:   3900,
+			LoadWarehousesAzure: 3900,
+			LoadWarehousesIBM:   3900,
+			EstimatedMaxGCE:     3100,
+			EstimatedMaxAWS:     3600,
+			EstimatedMaxAzure:   3600,
+			EstimatedMaxIBM:     3600,
+			WriteOptimization:   registry.Buffering,
+
+			Clouds: registry.AllClouds,
+			Suites: registry.Suites(registry.Nightly),
+		},
+	)
+
+	// A variant with pipelining and buffering both enabled.
+	registerTPCCBenchSpec(
+		r, tpccBenchSpec{
+			Nodes: 3,
+			CPUs:  16,
+
+			LoadWarehousesGCE:   3500,
+			LoadWarehousesAWS:   3900,
+			LoadWarehousesAzure: 3900,
+			LoadWarehousesIBM:   3900,
+			EstimatedMaxGCE:     3100,
+			EstimatedMaxAWS:     3600,
+			EstimatedMaxAzure:   3600,
+			EstimatedMaxIBM:     3600,
+			WriteOptimization:   registry.PipeliningBuffering,
+
+			Clouds: registry.AllClouds,
+			Suites: registry.Suites(registry.Nightly),
+		},
+	)
 }
 
 func valueForCloud(cloud spec.Cloud, gce, aws, azure, ibm int) int {
@@ -1730,6 +1774,9 @@ type tpccBenchSpec struct {
 	// SharedProcessMT, if true, indicates that the cluster should run in
 	// shared-process mode of multi-tenancy.
 	SharedProcessMT bool
+	// WriteOptimization specifies the write optimization to use (e.g. pipelining,
+	// buffering, or both).
+	WriteOptimization registry.WriteOptimizationType
 }
 
 func (s tpccBenchSpec) EstimatedMax(cloud spec.Cloud) int {
@@ -1829,6 +1876,10 @@ func registerTPCCBenchSpec(r registry.Registry, b tpccBenchSpec) {
 		nameParts = append(nameParts, "mt-shared-process")
 	}
 
+	if b.WriteOptimization != registry.DefaultWriteOptimization {
+		nameParts = append(nameParts, fmt.Sprintf("write-optimization=%s", b.WriteOptimization.String()))
+	}
+
 	name := strings.Join(nameParts, "/")
 
 	numNodes := b.Nodes + b.LoadConfig.numLoadNodes(b.Distribution)
@@ -1844,6 +1895,7 @@ func registerTPCCBenchSpec(r registry.Registry, b tpccBenchSpec) {
 		Suites:                 b.Suites,
 		EncryptionSupport:      encryptionSupport,
 		Leases:                 leases,
+		WriteOptimization:      b.WriteOptimization,
 		PostProcessPerfMetrics: getMaxWarehousesAboveEfficiency,
 		Run: func(ctx context.Context, t test.Test, c cluster.Cluster) {
 			runTPCCBench(ctx, t, c, b)