handling large vu shifts

lib/executor/helpers.go

@@ -33,6 +33,32 @@ func getStagesUnscaledMaxTarget(unscaledStartValue int64, stages []Stage) int64
 	return max
 }
 
+func validateNumberOfVuShifts(startVus int64, stages []Stage) []error {
+	const MaxRampingVUShift = 100000000
+
+	var errors []error
+	totalShifts := big.NewInt(startVus)
+	prevNumVus := totalShifts
+
+	for _, s := range stages {
+		current := big.NewInt(s.Target.Int64)
+		vuDelta := new(big.Int).Sub(current, prevNumVus)
+		vuDelta.Abs(vuDelta)
+
+		totalShifts.Add(totalShifts, vuDelta)
+
+		prevNumVus = current
+	}
+
+	totalShifts.Add(totalShifts, prevNumVus)
+
+	if totalShifts.Cmp(big.NewInt(MaxRampingVUShift)) > 0 {
+		errors = append(errors, fmt.Errorf("total number of VU shifts is too large"))
+	}
+
+	return errors
+}
+
 // A helper function to avoid code duplication
 func validateStages(stages []Stage) []error {
 	var errors []error

lib/executor/ramping_arrival_rate.go

@@ -95,6 +95,7 @@ func (varc *RampingArrivalRateConfig) Validate() []error {
 		errors = append(errors, fmt.Errorf("the timeUnit must be more than 0"))
 	}
 
+	errors = append(errors, validateNumberOfVuShifts(varc.StartRate.Int64, varc.Stages)...)
 	errors = append(errors, validateStages(varc.Stages)...)
 
 	if !varc.PreAllocatedVUs.Valid {

lib/executor/ramping_vus.go

@@ -86,7 +86,10 @@ func (vlvc RampingVUsConfig) Validate() []error {
 		errors = append(errors, fmt.Errorf("either startVUs or one of the stages' target values must be greater than 0"))
 	}
 
-	return append(errors, validateStages(vlvc.Stages)...)
+	errors = append(errors, validateNumberOfVuShifts(vlvc.StartVUs.Int64, vlvc.Stages)...)
+	errors = append(errors, validateStages(vlvc.Stages)...)
+
+	return errors
 }
 
 // getRawExecutionSteps calculates and returns as execution steps the number of

lib/executor/ramping_vus_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"math"
 	"math/big"
 	"math/rand"
 	"sync/atomic"
@@ -36,6 +37,34 @@ func TestRampingVUsConfigValidation(t *testing.T) {
 	errs = c.Validate()
 	require.NotEmpty(t, errs)
 	assert.Contains(t, errs[0].Error(), "greater than 0")
+
+	t.Run("validate large VU shifts should fail", func(t *testing.T) {
+		t.Parallel()
+
+		const MaxRampingVUShift = 100000000
+		const HalfMaxRampingVUShift = MaxRampingVUShift / 2
+		const HalfMaxInt = math.MaxInt64 / 2
+
+		c.StartVUs = null.IntFrom(MaxRampingVUShift)
+		errs = c.Validate()
+		require.NotEmpty(t, errs)
+		assert.Contains(t, errs[0].Error(), "number of VU shifts is too large")
+
+		c.StartVUs = null.IntFrom(0)
+		c.Stages = []Stage{
+			{Target: null.IntFrom(HalfMaxRampingVUShift + 1), Duration: types.NullDurationFrom(12 * time.Second)},
+		}
+		errs = c.Validate()
+		assert.Contains(t, errs[0].Error(), "number of VU shifts is too large")
+
+		// Integer overflow is correctly handled
+		c.StartVUs = null.IntFrom(0)
+		c.Stages = []Stage{
+			{Target: null.IntFrom(HalfMaxInt + 1), Duration: types.NullDurationFrom(12 * time.Second)},
+		}
+		errs = c.Validate()
+		assert.Contains(t, errs[0].Error(), "number of VU shifts is too large")
+	})
 }
 
 func TestRampingVUsRun(t *testing.T) {