Merge #153545

153545: asim: output test set up if eval has full = true r=tbg a=wenyihu6

Resolves: #153572
Release note: none

---
**asim: add a separator line after each run**

This commit updates asim output to add a separate line after each simulation run
to improve readability.

---
**asim: export DefaultStartTime**

This commit exports the simulator’s default start time, which will be used in
future commits to compare against scheduled event timestamps in the scheduler
package, ensuring timestamp is printed only when not at the start time.

---
**asim: move some variables to an outer scope**

This commit moves certain variables above the configuration declarations so they
can be reused in an outer scope.

---
**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.

---
**asim: remove run.stateStrAcrossSamples append**

This commit removes an unused run.stateStrAcrossSamples append. I left the field
itself in place in the struct since it causes no harm, though we can consider
deleting it entirely.

---
**asim: print simulation setting as part of * _setup.txt**

This commit includes simulation settings in the setup output. Only values that
differ from the default simulation settings are printed. Note that cluster
settings and the seed are omitted. The simulation seed is derived from
rand.New(rand.NewSource(42)).Int63() by default, while the default simulation
setting itself uses 42.

Note that we rely on users to explicitly reset cluster settings between runs. It
isn’t an issue now, but it may become a potential footgun in the future.

---
**asim: print store info to * _setup.txt**

This commit outputs store capacity and store attributes t.o the setup file.

---
**asim: output test set up if eval has full = true**

This commit adds an optional parameter to eval that outputs the test setup. By
default, the setup is only written to the generated folder as
{TESTNAME}_setup.txt.


Co-authored-by: wenyihu6 <[email protected]>

Author: craig[bot]

pkg/kv/kvserver/asim/config/settings.go

@@ -33,10 +33,10 @@ const (
 )
 
 var (
-	// defaultStartTime is used as the default beginning time for simulation
+	// DefaultStartTime is used as the default beginning time for simulation
 	// runs. It isn't necessarily meaningful other than for logging and having
 	// "some" start time for components taking a time.Time.
-	defaultStartTime = time.Date(2022, 03, 21, 11, 0, 0, 0, time.UTC)
+	DefaultStartTime = time.Date(2022, 03, 21, 11, 0, 0, 0, time.UTC)
 )
 
 // SimulationSettings controls
@@ -116,7 +116,7 @@ type SimulationSettings struct {
 // DefaultSimulationSettings returns a set of default settings for simulation.
 func DefaultSimulationSettings() *SimulationSettings {
 	return &SimulationSettings{
-		StartTime:               defaultStartTime,
+		StartTime:               DefaultStartTime,
 		TickInterval:            defaultTickInteval,
 		MetricsInterval:         defaultMetricsInterval,
 		Seed:                    defaultSeed,

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 {
@@ -119,7 +169,7 @@ func (sce SetCapacityOverrideEvent) Func() EventFunc {
 }
 
 func (sce SetCapacityOverrideEvent) String() string {
-	return fmt.Sprintf("set capacity override event with storeID=%d, capacity_override=%v", sce.StoreID, sce.CapacityOverride)
+	return fmt.Sprintf("override s%d capacity to %v", sce.StoreID, sce.CapacityOverride)
 }
 
 func (sne SetNodeLocalityEvent) 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, settings)
 	return asim.NewSimulator(
 		duration,
 		loadGen.Generate(seed, &settings),
@@ -101,11 +103,14 @@ type MultiLoad []BasicLoad
 var _ LoadGen = MultiLoad{}
 
 func (ml MultiLoad) String() string {
-	var str string
-	for _, load := range ml {
-		str += fmt.Sprintf("%s\n", load.String())
+	var buf strings.Builder
+	for i, load := range ml {
+		_, _ = fmt.Fprintf(&buf, "%s", load.String())
+		if i != len(ml)-1 {
+			_, _ = fmt.Fprintf(&buf, "\n")
+		}
 	}
-	return str
+	return buf.String()
 }
 
 func (ml MultiLoad) Generate(seed int64, settings *config.SimulationSettings) []workload.Generator {
@@ -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
@@ -393,21 +423,33 @@ type MultiRanges []BasicRanges
 var _ RangeGen = MultiRanges{}
 
 func (mr MultiRanges) String() string {
-	var str string
-	for _, ranges := range mr {
-		str += fmt.Sprintf("%s\n", ranges.String())
+	var buf strings.Builder
+	for i, ranges := range mr {
+		_, _ = fmt.Fprintf(&buf, "%s", ranges.String())
+		if i != len(mr)-1 {
+			_, _ = fmt.Fprintf(&buf, "\n")
+		}
 	}
-	return str
+	return buf.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 i, str := range rangeInfoStrings {
+		_, _ = fmt.Fprintf(&buf, "%s", str)
+		if i != len(rangeInfoStrings)-1 {
+			_, _ = fmt.Fprintf(&buf, "\n")
+		}
+	}
+	return s, buf.String()
 }