Function TestLimiterDeadlock

worker/proposal_test.go:58–106

This test tests for deadlock in rate limiter. It tried some fixed number of proposals in multiple goroutines. At the end it matches if sum of completed and aborted proposals is equal to tried proposals or not.

(t *testing.T)

// multiple goroutines. At the end it matches if sum of completed and aborted proposals is
// equal to tried proposals or not.
func TestLimiterDeadlock(t *testing.T) {
	toTry := int64(3000) // total proposals count to propose.
	var currentCount, pending, completed, aborted int64

	l := &rateLimiter{c: sync.NewCond(&sync.Mutex{}), max: 256}
	go l.bleed()

	ticker := time.Tick(time.Second)

	go func() {
		now := time.Now()
		for range ticker {
			l.c.L.Lock()
			fmt.Println("Seconds elapsed :", int64(time.Since(now).Seconds()),
				"Total proposals: ", atomic.LoadInt64(&currentCount),
				"Pending proposal: ", atomic.LoadInt64(&pending),
				"Completed Proposals: ", atomic.LoadInt64(&completed),
				"Aborted Proposals: ", atomic.LoadInt64(&aborted),
				"IOU: ", l.iou)
			l.c.L.Unlock()
		}
	}()

	var wg sync.WaitGroup
	for i := range 500 {
		wg.Add(1)
		go func(no int) {
			defer wg.Done()
			r := rand.New(rand.NewSource(time.Now().UnixNano()))
			for {
				if atomic.AddInt64(&currentCount, 1) > toTry {
					break
				}
				atomic.AddInt64(&pending, 1)
				if err := proposeAndWaitEmulator(l, r, 3, true); err != nil {
					atomic.AddInt64(&aborted, 1)
				} else {
					atomic.AddInt64(&completed, 1)
				}
				atomic.AddInt64(&pending, -1)
			}
		}(i)
	}
	wg.Wait()

	// After trying all the proposals, (completed + aborted) should be equal to  tried proposal.
	require.True(t, toTry == completed+aborted,
		fmt.Sprintf("Tried: %d, Compteted: %d, Aborted: %d", toTry, completed, aborted))
}

func BenchmarkRateLimiter(b *testing.B) {
	ious := []int{256}