fix load gen worker tick interval math to avoid div by zero

Author: gavincabbage

testbed/testbed/load_generator.go

@@ -213,12 +213,14 @@ func (ps *ProviderSender) generate() {
 
 	var workers sync.WaitGroup
 
+	tickDuration := ps.perWorkerTickDuration(numWorkers)
+
 	for i := 0; i < numWorkers; i++ {
 		workers.Add(1)
 
 		go func() {
-			defer workers.Done()
-			t := time.NewTicker(time.Second / time.Duration(ps.options.DataItemsPerSecond/ps.options.ItemsPerBatch/numWorkers))
+
+			t := time.NewTicker(tickDuration)
 			defer t.Stop()
 
 			var prevErr error
@@ -338,3 +340,15 @@ func (ps *ProviderSender) generateLog() error {
 		}
 	}
 }
+
+// perWorkerTickDuration calculates the tick interval each worker must observe in order to
+// produce the desired average DataItemsPerSecond given the constraints of ItemsPerBatch and numWorkers.
+//
+// Of particular note are cases when the batchesPerSecond required of each worker is less than one due to a high
+// number of workers relative to the desired DataItemsPerSecond. If the total batchesPerSecond is less than the
+// number of workers then we are dealing with fractional batches per second per worker, so we need float arithmetic.
+func (ps *ProviderSender) perWorkerTickDuration(numWorkers int) time.Duration {
+	batchesPerSecond := float64(ps.options.DataItemsPerSecond) / float64(ps.options.ItemsPerBatch)
+	batchesPerSecondPerWorker := batchesPerSecond / float64(numWorkers)
+	return time.Duration(float64(time.Second) / batchesPerSecondPerWorker)
+}

testbed/testbed/load_generator_test.go

@@ -0,0 +1,58 @@
+package testbed
+
+import (
+	"testing"
+	"time"
+)
+
+func Test_perWorkerTickDuration(t *testing.T) {
+	for _, test := range []struct {
+		name                                          string
+		expectedTickDuration                          time.Duration
+		dataItemsPerSecond, itemsPerBatch, numWorkers int
+	}{
+		// Because of the way perWorkerTickDuration calculates the tick interval using dataItemsPerSecond,
+		// it is important to test its behavior with respect to a one-second Duration in particular.
+		{
+			name:                 "less than one second",
+			expectedTickDuration: 100 * time.Millisecond,
+			dataItemsPerSecond:   100,
+			itemsPerBatch:        5,
+			numWorkers:           2,
+		},
+		{
+			name:                 "exactly one second",
+			expectedTickDuration: time.Second,
+			dataItemsPerSecond:   100,
+			itemsPerBatch:        5,
+			numWorkers:           20,
+		},
+		{
+			name:                 "more than one second",
+			expectedTickDuration: 5 * time.Second,
+			dataItemsPerSecond:   100,
+			itemsPerBatch:        5,
+			numWorkers:           100,
+		},
+		{
+			name:                 "default batch size and worker count",
+			expectedTickDuration: 8103727, // ~8.1ms
+			dataItemsPerSecond:   1234,
+			itemsPerBatch:        10,
+			numWorkers:           1,
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			subject := &ProviderSender{
+				options: LoadOptions{
+					DataItemsPerSecond: test.dataItemsPerSecond,
+					ItemsPerBatch:      test.itemsPerBatch,
+				},
+			}
+			actual := subject.perWorkerTickDuration(test.numWorkers)
+			if actual != test.expectedTickDuration {
+				t.Errorf("got %v; want %v", actual, test.expectedTickDuration)
+			}
+		})
+	}
+}