kvserver: rename a field

This is a more evocative name - we're measuring when the event was queued, but
not when it was processed.

Author: tbg

pkg/kv/kvserver/scheduler.go

@@ -143,8 +143,8 @@ const (
 )
 
 type raftScheduleState struct {
-	flags raftScheduleFlags
-	begin crtime.Mono
+	flags  raftScheduleFlags
+	queued crtime.Mono
 
 	// The number of ticks queued. Usually it's 0 or 1, but may go above if the
 	// scheduling or processing is slow. It is limited by raftScheduler.maxTicks,
@@ -393,10 +393,10 @@ func (ss *raftSchedulerShard) worker(
 		ss.Unlock()
 
 		// Record the scheduling latency for the range.
-		if buildutil.CrdbTestBuild && state.begin == 0 {
-			log.Fatalf(ctx, "raftSchedulerShard.worker called with zero begin: %+v", state)
+		if buildutil.CrdbTestBuild && state.queued == 0 {
+			log.Fatalf(ctx, "raftSchedulerShard.worker called with zero queued: %+v", state)
 		}
-		lat := state.begin.Elapsed()
+		lat := state.queued.Elapsed()
 		metrics.RaftSchedulerLatency.RecordValue(int64(lat))
 
 		// Process requests first. This avoids a scenario where a tick and a
@@ -470,7 +470,7 @@ func (ss *raftSchedulerShard) worker(
 			// can not possibly happen before the current processing is done (i.e.
 			// now). We do not want the scheduler latency to pick up the time spent
 			// handling this replica.
-			state.begin = crtime.NowMono()
+			state.queued = crtime.NowMono()
 			ss.state[id] = state
 			ss.queue.Push(id)
 		}
@@ -503,10 +503,10 @@ func (ss *raftSchedulerShard) enqueue1Locked(
 	if newState.flags&stateQueued == 0 {
 		newState.flags |= stateQueued
 		queued++
-		if buildutil.CrdbTestBuild && newState.begin != 0 {
-			log.Fatalf(context.Background(), "raftSchedulerShard.enqueue1Locked called with non-zero begin: %+v", newState)
+		if buildutil.CrdbTestBuild && newState.queued != 0 {
+			log.Fatalf(context.Background(), "raftSchedulerShard.enqueue1Locked called with non-zero queued: %+v", newState)
 		}
-		newState.begin = now
+		newState.queued = now
 		ss.queue.Push(id)
 	}
 	ss.state[id] = newState

pkg/kv/kvserver/scheduler_test.go

@@ -390,9 +390,9 @@ func TestSchedulerEnqueueWhileProcessing(t *testing.T) {
 	p.testEventCh <- func(id roachpb.RangeID, ss *raftSchedulerShard, ev raftScheduleState) {
 		// First call into this method.
 		//
-		// The event calling into us must have `ev.begin` set; it was set when
+		// The event calling into us must have `ev.queued` set; it was set when
 		// enqueuing.
-		assert.NotZero(t, ev.begin)
+		assert.NotZero(t, ev.queued)
 
 		// Even though our event is currently being processed, there is a queued
 		// and otherwise blank event in the scheduler state (which is how we have
@@ -402,7 +402,7 @@ func TestSchedulerEnqueueWhileProcessing(t *testing.T) {
 		statePre := ss.state[id]
 		ss.Unlock()
 
-		assert.Zero(t, statePre.begin)
+		assert.Zero(t, statePre.queued)
 		assert.Equal(t, stateQueued, statePre.flags)
 
 		// Simulate a concurrent actor that enqueues the same range again.
@@ -411,21 +411,21 @@ func TestSchedulerEnqueueWhileProcessing(t *testing.T) {
 		s.enqueue1(stateTestIntercept, 1)
 
 		// Seeing that there is an existing "queued" event, the enqueue call below
-		// should not populate `begin`.  Instead, this will be the job of our
+		// should not populate `queued`.  Instead, this will be the job of our
 		// caller when it *actually* pushes into the queue again after fully
 		// having handled `ev`.
 		ss.Lock()
 		statePost := ss.state[id]
 		ss.Unlock()
 
-		assert.Zero(t, statePost.begin)
+		assert.Zero(t, statePost.queued)
 		assert.Equal(t, stateQueued|stateTestIntercept, statePost.flags)
 		close(done)
 	}
 	p.testEventCh <- func(id roachpb.RangeID, shard *raftSchedulerShard, ev raftScheduleState) {
 		// Second call into this method, i.e. the overlappingly-enqeued event is
-		// being processed. Check that `begin` is now set.
-		assert.NotZero(t, ev.begin)
+		// being processed. Check that `queued` is now set.
+		assert.NotZero(t, ev.queued)
 	}
 	s.enqueue1(stateTestIntercept, 1) // will become 'ev' in the intercept
 	select {