asim: generate {TESTNAME}_setup.txt

This commit adds a test setup string which will be outputted to
{TESTNAME}_setup.txt. Only the first configuration and first sample are emitted,
since the setup should effectively be the same across runs (other than
LBRebalancingMode) and duplicating it would add unnecessary runtime churn. One
downside is that the scheduled event for LBRebalancingMode will only reflect the
first occurrence. If a datadriven test contains multiple evals, the last one
wins.

Author: wenyihu6

pkg/kv/kvserver/asim/event/mutation_event.go

@@ -8,6 +8,7 @@ package event
 import (
 	"context"
 	"fmt"
+	"strings"
 
 	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/asim/state"
 	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/liveness/livenesspb"
@@ -73,7 +74,51 @@ func (se SetSpanConfigEvent) Func() EventFunc {
 }
 
 func (se SetSpanConfigEvent) String() string {
-	return fmt.Sprintf("set span config event with span=%v, config=%v", se.Span, &se.Config)
+	var buf strings.Builder
+	voter, nonvoter := se.Config.GetNumVoters(), se.Config.GetNumNonVoters()
+	var nonvoterStr string
+	if nonvoter != 0 {
+		nonvoterStr = fmt.Sprintf(",%dnonvoters", nonvoter)
+	}
+	_, _ = fmt.Fprintf(&buf, "[%s,%s): %dvoters%s", se.Span.Key, se.Span.EndKey, voter, nonvoterStr)
+
+	printConstraint := func(tag string, constraints []roachpb.ConstraintsConjunction) {
+		if len(constraints) != 0 {
+			_, _ = fmt.Fprintf(&buf, "%s", tag)
+			for _, c := range constraints {
+				_, _ = fmt.Fprintf(&buf, "{%d:", c.NumReplicas)
+				for j, constraint := range c.Constraints {
+					_, _ = fmt.Fprintf(&buf, "%s=%s", constraint.Key, constraint.Value)
+					if j != len(c.Constraints)-1 {
+						_, _ = fmt.Fprintf(&buf, ",")
+					}
+				}
+				_, _ = fmt.Fprintf(&buf, "}")
+			}
+			_, _ = fmt.Fprintf(&buf, "]")
+		}
+	}
+	printConstraint(" [replicas:", se.Config.Constraints)
+	printConstraint(" [voters:", se.Config.VoterConstraints)
+	if len(se.Config.LeasePreferences) != 0 {
+		_, _ = fmt.Fprint(&buf, " [lease:")
+		for i, lp := range se.Config.LeasePreferences {
+			_, _ = fmt.Fprint(&buf, "{")
+			for j, c := range lp.Constraints {
+				_, _ = fmt.Fprintf(&buf, "%s=%s", c.Key, c.Value)
+				if j != len(lp.Constraints)-1 {
+					_, _ = fmt.Fprintf(&buf, ",")
+				}
+			}
+			_, _ = fmt.Fprintf(&buf, "}")
+			if i != len(se.Config.LeasePreferences)-1 {
+				_, _ = fmt.Fprintf(&buf, ">")
+			}
+		}
+		_, _ = fmt.Fprint(&buf, "]")
+	}
+	noQuotesBuf := strings.ReplaceAll(buf.String(), "\"", "")
+	return noQuotesBuf
 }
 
 func (ae AddNodeEvent) Func() EventFunc {
@@ -95,7 +140,12 @@ func (ae AddNodeEvent) Func() EventFunc {
 }
 
 func (ae AddNodeEvent) String() string {
-	return fmt.Sprintf("add node event with num_of_stores=%d, locality_string=%s", ae.NumStores, ae.LocalityString)
+	var buf strings.Builder
+	_, _ = fmt.Fprintf(&buf, "add node with %d stores", ae.NumStores)
+	if ae.LocalityString != "" {
+		_, _ = fmt.Fprintf(&buf, ", locality_string=%s", ae.LocalityString)
+	}
+	return buf.String()
 }
 
 func (sne SetNodeLivenessEvent) Func() EventFunc {
@@ -108,7 +158,7 @@ func (sne SetNodeLivenessEvent) Func() EventFunc {
 }
 
 func (sne SetNodeLivenessEvent) String() string {
-	return fmt.Sprintf("set node liveness event with nodeID=%d, liveness_status=%v", sne.NodeId, sne.LivenessStatus)
+	return fmt.Sprintf("set n%d to %v", sne.NodeId, sne.LivenessStatus)
 }
 
 func (sce SetCapacityOverrideEvent) Func() EventFunc {
@@ -150,5 +200,5 @@ func (se SetSimulationSettingsEvent) Func() EventFunc {
 }
 
 func (se SetSimulationSettingsEvent) String() string {
-	return fmt.Sprintf("set simulation settings event with key=%s, value=%v", se.Key, se.Value)
+	return fmt.Sprintf("set %s to %v", se.Key, se.Value)
 }

pkg/kv/kvserver/asim/gen/BUILD.bazel

@@ -5,6 +5,7 @@ go_library(
     srcs = [
         "event_generator.go",
         "generator.go",
+        "printer.go",
     ],
     importpath = "github.com/cockroachdb/cockroach/pkg/kv/kvserver/asim/gen",
     visibility = ["//visibility:public"],

pkg/kv/kvserver/asim/gen/generator.go

@@ -51,7 +51,7 @@ type RangeGen interface {
 	// Generate returns an updated state, given the initial state, seed and
 	// simulation settings provided. In the updated state, ranges will have been
 	// created, replicas and leases assigned to stores in the cluster.
-	Generate(seed int64, settings *config.SimulationSettings, s state.State) state.State
+	Generate(seed int64, settings *config.SimulationSettings, s state.State) (state.State, string)
 	String() string
 }
 
@@ -65,11 +65,13 @@ func GenerateSimulation(
 	settingsGen SettingsGen,
 	eventGen EventGen,
 	seed int64,
+	buf *strings.Builder,
 ) *asim.Simulator {
 	settings := settingsGen.Generate(seed)
 	s := clusterGen.Generate(seed, &settings)
-	s = rangeGen.Generate(seed, &settings, s)
+	s, rangeStateStr := rangeGen.Generate(seed, &settings, s)
 	eventExecutor := eventGen.Generate(seed, &settings)
+	generateClusterVisualization(buf, s, loadGen, eventGen, rangeStateStr)
 	return asim.NewSimulator(
 		duration,
 		loadGen.Generate(seed, &settings),
@@ -102,8 +104,11 @@ var _ LoadGen = MultiLoad{}
 
 func (ml MultiLoad) String() string {
 	var str string
-	for _, load := range ml {
-		str += fmt.Sprintf("%s\n", load.String())
+	for i, load := range ml {
+		if i > 0 {
+			str += "\n"
+		}
+		str += load.String()
 	}
 	return str
 }
@@ -131,11 +136,36 @@ type BasicLoad struct {
 var _ LoadGen = BasicLoad{}
 
 func (bl BasicLoad) String() string {
-	return fmt.Sprintf(
-		"basic load with rw_ratio=%0.2f, rate=%0.2f, skewed_access=%t, min_block_size=%d, max_block_size=%d, "+
-			"min_key=%d, max_key=%d, request_cpu_per_access=%d, raft_cpu_per_write=%d",
-		bl.RWRatio, bl.Rate, bl.SkewedAccess, bl.MinBlockSize, bl.MaxBlockSize,
-		bl.MinKey, bl.MaxKey, bl.RequestCPUPerAccess, bl.RaftCPUPerWrite)
+	var buf strings.Builder
+	fmt.Fprintf(&buf, "\t[%d,%d): ", bl.MinKey, bl.MaxKey)
+	if bl.RWRatio == 1 {
+		_, _ = fmt.Fprint(&buf, "read-only")
+	} else if bl.RWRatio == 0 {
+		_, _ = fmt.Fprint(&buf, "write-only")
+	} else {
+		_, _ = fmt.Fprintf(&buf, "%d%%r", int(bl.RWRatio*100))
+	}
+	if bl.RequestCPUPerAccess > 0 {
+		_, _ = fmt.Fprint(&buf, " high-cpu")
+	}
+	if bl.MinBlockSize > 1 && bl.MaxBlockSize > 1 {
+		_, _ = fmt.Fprint(&buf, " large-block")
+	}
+	_, _ = fmt.Fprint(&buf, " [")
+
+	if bl.RequestCPUPerAccess > 0 {
+		_, _ = fmt.Fprintf(&buf, "%.2fcpu-us/op, ", float64(bl.RequestCPUPerAccess/time.Microsecond.Nanoseconds()))
+	}
+	if bl.RaftCPUPerWrite > 0 {
+		_, _ = fmt.Fprintf(&buf, "%.2fcpu-us/write(raft), ", float64(bl.RaftCPUPerWrite/time.Microsecond.Nanoseconds()))
+	}
+	if bl.MinBlockSize == bl.MaxBlockSize {
+		_, _ = fmt.Fprintf(&buf, "%dB/op, ", bl.MinBlockSize)
+	} else {
+		_, _ = fmt.Fprintf(&buf, "%d-%dB/op, ", bl.MinBlockSize, bl.MaxBlockSize)
+	}
+	fmt.Fprintf(&buf, "%gops/s]", bl.Rate)
+	return buf.String()
 }
 
 // Generate returns a new list of workload generators where the generator
@@ -184,7 +214,7 @@ func (lc LoadedCluster) Generate(seed int64, settings *config.SimulationSettings
 }
 
 func (lc LoadedCluster) String() string {
-	return fmt.Sprintf("loaded cluster with\n %v", lc.Info)
+	return fmt.Sprintf("cluster: %s", lc.Info.String())
 }
 
 func (lc LoadedCluster) Regions() []state.Region {
@@ -204,11 +234,12 @@ type BasicCluster struct {
 func (bc BasicCluster) String() string {
 	var b strings.Builder
 	_, _ = fmt.Fprintf(&b,
-		"basic cluster with nodes=%d, stores_per_node=%d, store_byte_capacity=%d, node_cpu_rate_capacity=%d",
-		bc.Nodes, bc.StoresPerNode, bc.StoreByteCapacity, bc.NodeCPURateCapacity)
+		"[nodes: %d, stores_per_node:%d, store_disk_capacity: %dGiB, node_capacity: %dcpu-sec/sec",
+		bc.Nodes, bc.StoresPerNode, bc.StoreByteCapacity>>30, bc.NodeCPURateCapacity/time.Second.Nanoseconds())
 	if len(bc.Region) != 0 {
-		_, _ = fmt.Fprintf(&b, ", region=%v, nodes_per_region=%v", bc.Region, bc.NodesPerRegion)
+		_, _ = fmt.Fprintf(&b, ", region: %v, nodes_per_region: %v", bc.Region, bc.NodesPerRegion)
 	}
+	b.WriteString("]")
 	return b.String()
 }
 
@@ -325,15 +356,11 @@ type BaseRanges struct {
 	ReplicaPlacement  state.ReplicaPlacement
 }
 
-func (b BaseRanges) String() string {
-	return fmt.Sprintf("ranges=%d, min_key=%d, max_key=%d, replication_factor=%d, bytes=%d", b.Ranges, b.MinKey, b.MaxKey, b.ReplicationFactor, b.Bytes)
-}
-
 // GetRangesInfo generates and distributes ranges across stores based on
 // PlacementType while using other BaseRanges fields for range configuration.
 func (b BaseRanges) GetRangesInfo(
 	pType PlacementType, numOfStores int, randSource *rand.Rand, weightedRandom []float64,
-) state.RangesInfo {
+) (state.RangesInfo, string) {
 	switch pType {
 	case Even:
 		return state.RangesInfoEvenDistribution(numOfStores, b.Ranges, b.MinKey, b.MaxKey, b.ReplicationFactor, b.Bytes)
@@ -369,21 +396,24 @@ type BasicRanges struct {
 }
 
 func (br BasicRanges) String() string {
-	return fmt.Sprintf("basic ranges with placement_type=%v, %v", br.PlacementType, br.BaseRanges)
+	return fmt.Sprintf("[%d,%d): %d(rf=%d), %dMiB",
+		br.MinKey, br.MaxKey, br.Ranges, br.ReplicationFactor, br.Bytes>>20)
 }
 
 // Generate returns an updated simulator state, where the cluster is loaded with
 // ranges generated based on the parameters specified in the fields of
 // BasicRanges.
 func (br BasicRanges) Generate(
 	seed int64, settings *config.SimulationSettings, s state.State,
-) state.State {
+) (state.State, string) {
 	if br.PlacementType == Random || br.PlacementType == WeightedRandom {
 		panic("BasicRanges generate only uniform or skewed distributions")
 	}
-	rangesInfo := br.GetRangesInfo(br.PlacementType, len(s.Stores()), nil, []float64{})
+	rangesInfo, str := br.GetRangesInfo(br.PlacementType, len(s.Stores()), nil, []float64{})
 	br.LoadRangeInfo(s, rangesInfo)
-	return s
+	var buf strings.Builder
+	_, _ = fmt.Fprintf(&buf, "\t%s, %s", br, str)
+	return s, buf.String()
 }
 
 // MultiRanges implements the RangeGen interface, supporting multiple
@@ -402,12 +432,18 @@ func (mr MultiRanges) String() string {
 
 func (mr MultiRanges) Generate(
 	seed int64, settings *config.SimulationSettings, s state.State,
-) state.State {
+) (state.State, string) {
 	var rangeInfos []state.RangeInfo
+	var rangeInfoStrings []string
 	for _, ranges := range mr {
-		rangeInfos = append(rangeInfos,
-			ranges.GetRangesInfo(ranges.PlacementType, len(s.Stores()), nil, []float64{})...)
+		rangeInfo, rangeInfoStr := ranges.GetRangesInfo(ranges.PlacementType, len(s.Stores()), nil, []float64{})
+		rangeInfos = append(rangeInfos, rangeInfo...)
+		rangeInfoStrings = append(rangeInfoStrings, fmt.Sprintf("\t%s, %s", ranges.String(), rangeInfoStr))
 	}
 	state.LoadRangeInfo(s, rangeInfos...)
-	return s
+	var buf strings.Builder
+	for _, str := range rangeInfoStrings {
+		_, _ = fmt.Fprintf(&buf, "%s\n", str)
+	}
+	return s, buf.String()
 }

pkg/kv/kvserver/asim/gen/printer.go

@@ -0,0 +1,43 @@
+// Copyright 2023 The Cockroach Authors.
+//
+// Use of this software is governed by the CockroachDB Software License
+// included in the /LICENSE file.
+
+package gen
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/asim/state"
+)
+
+// generateClusterVisualization generates a visualization of the cluster state.
+// Example: mma_one_voter_skewed_cpu_skewed_write_setup.txt.
+//
+// Cluster Set Up
+// n1(AU_EAST,AU_EAST_1,0vcpu): {s1}
+// n2(AU_EAST,AU_EAST_1,0vcpu): {s2}
+// Key Space
+// [1,10000): 100(rf=1), 25MiB, [{s1*}:100]
+// [10001,20000): 100(rf=1), 25MiB, [{s2*}:100]
+// Event
+// set LBRebalancingMode to 4
+// Workload Set Up
+// [1,10000): read-only high-cpu [500.00cpu-us/op, 1B/op, 1000ops/s]
+// [10001,20000): write-only large-block [0.00cpu-us/write(raft), 1000B/op, 5000ops/s]
+func generateClusterVisualization(
+	buf *strings.Builder, s state.State, loadGen LoadGen, eventGen EventGen, rangeStateStr string,
+) {
+	if buf == nil {
+		return
+	}
+	_, _ = fmt.Fprintf(buf, "Cluster Set Up\n")
+	for _, n := range s.Nodes() {
+		_, _ = fmt.Fprintf(buf, "%v", n)
+		_, _ = fmt.Fprintf(buf, "\n")
+	}
+	_, _ = fmt.Fprintf(buf, "Key Space\n%s", rangeStateStr)
+	_, _ = fmt.Fprintf(buf, "Event\n%s", eventGen.String())
+	_, _ = fmt.Fprintf(buf, "Workload Set Up\n%s", loadGen.String())
+}

pkg/kv/kvserver/asim/scheduled/BUILD.bazel

@@ -9,6 +9,7 @@ go_library(
     importpath = "github.com/cockroachdb/cockroach/pkg/kv/kvserver/asim/scheduled",
     visibility = ["//visibility:public"],
     deps = [
+        "//pkg/kv/kvserver/asim/config",
         "//pkg/kv/kvserver/asim/event",
         "//pkg/kv/kvserver/asim/history",
         "//pkg/kv/kvserver/asim/state",

pkg/kv/kvserver/asim/scheduled/scheduled_event.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/asim/config"
 	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/asim/event"
 )
 
@@ -40,8 +41,10 @@ type ScheduledEvent struct {
 
 func (se ScheduledEvent) String() string {
 	buf := strings.Builder{}
-	buf.WriteString(fmt.Sprintf("\texecuted at: %s\n", se.At.Format("2006-01-02 15:04:05")))
-	buf.WriteString(fmt.Sprintf("\t\tevent: %s", se.TargetEvent.String()))
+	buf.WriteString(fmt.Sprintf("\t%s", se.TargetEvent.String()))
+	if !se.At.Equal(config.DefaultStartTime) {
+		buf.WriteString(fmt.Sprintf(" at %s", se.At.Format("15:04:05")))
+	}
 	return buf.String()
 }
 

pkg/kv/kvserver/asim/scheduled/scheduled_event_executor.go

@@ -70,15 +70,17 @@ func newExecutorWithNoEvents() *eventExecutor {
 // assertion events.
 func (e *eventExecutor) PrintEventSummary() string {
 	mutationEvents, assertionEvents := 0, 0
+	var buf strings.Builder
+	sort.Sort(e.scheduledEvents)
 	for _, e := range e.scheduledEvents {
+		_, _ = fmt.Fprintf(&buf, "%v\n", e)
 		if e.IsMutationEvent() {
 			mutationEvents++
 		} else {
 			assertionEvents++
 		}
 	}
-	return fmt.Sprintf(
-		"number of mutation events=%d, number of assertion events=%d", mutationEvents, assertionEvents)
+	return buf.String()
 }
 
 // PrintEventsExecuted returns a detailed string representation of executed

pkg/kv/kvserver/asim/state/config_loader.go

@@ -283,8 +283,8 @@ type ClusterInfo struct {
 
 func (c ClusterInfo) String() (s string) {
 	buf := &strings.Builder{}
-	for i, r := range c.Regions {
-		buf.WriteString(fmt.Sprintf("\t\tregion:%s [", r.Name))
+	for _, r := range c.Regions {
+		buf.WriteString(fmt.Sprintf("region:%s [", r.Name))
 		if len(r.Zones) == 0 {
 			panic(fmt.Sprintf("number of zones within region %s is zero", r.Name))
 		}
@@ -295,10 +295,10 @@ func (c ClusterInfo) String() (s string) {
 			}
 		}
 		buf.WriteString("]")
-		if i != len(c.Regions)-1 {
-			buf.WriteString("\n")
-		}
+		buf.WriteString("\n")
 	}
+	buf.WriteString(fmt.Sprintf("store_disk_capacity=%d bytes, node_cpu_rate_capacity=%d cpu-ns/sec",
+		c.StoreDiskCapacityBytes, c.NodeCPURateCapacityNanos))
 	return buf.String()
 }