support very low rates

Author: linkdata

README.md

@@ -14,7 +14,7 @@ Only depends on the standard library.
 `go get github.com/linkdata/bwlimit`
 
 `Ticker` must be created with `bwlimit.NewTicker()`. The zero-value `Ticker` is not supported.
-Limits are enforced in 100ms slices. Very low limits are therefore approximate rather than exact.
+Limits are enforced in 100ms slices with fractional carry-over between slices, so very low limits are accurate over time but can still be bursty at slice boundaries.
 
 ## Example
 

limiter.go

@@ -15,7 +15,9 @@ type Limiter struct {
 // NewLimiter returns a new limiter from DefaultTicker.
 // If you provide limits, the first will set
 // both read and write limits, the second will set the write limit.
-// Limits are applied in 100ms slices, so very low rates are approximate.
+// Limits are applied in 100ms slices with fractional carry-over between
+// slices, so very low rates are accurate over time but can be bursty
+// at slice boundaries.
 //
 // To stop the Limiter and free it's resources, call Stop.
 func NewLimiter(limits ...int64) *Limiter {

operation.go

@@ -68,6 +68,7 @@ func (op *Operation) run(ch chan<- int64) {
 	stopCh := op.stopCh
 	seccount := 0
 	counts := make([]int64, secparts)
+	carry := int64(0)
 	op.mu.Unlock()
 
 	if stopCh != nil {
@@ -76,9 +77,16 @@ func (op *Operation) run(ch chan<- int64) {
 			var todo int64
 			var batch int64
 			if limit := op.Limit.Load(); limit > 0 {
-				limitCh = ch
-				todo = max(1, limit/secparts)
-				batch = min(batchsize, todo)
+				carry += limit
+				todo = carry / secparts
+				carry = carry % secparts
+				todo += op.avail.Swap(0)
+				if todo > 0 {
+					limitCh = ch
+					batch = min(batchsize, todo)
+				}
+			} else {
+				carry = 0
 			}
 			waitCh := op.WaitCh()
 

operation_test.go

@@ -170,6 +170,34 @@ func TestOperation_read_rate_low(t *testing.T) {
 	}
 }
 
+func TestOperation_read_rate_very_low(t *testing.T) {
+	l := NewLimiter(5)
+	defer l.Stop()
+
+	r := bytes.NewReader(make([]byte, 5))
+	buf := make([]byte, 5)
+
+	now := time.Now()
+	n, err := l.Reads.io(r.Read, buf)
+	elapsed := time.Since(now)
+
+	if n != 5 {
+		t.Fatal(n)
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// 5 bytes at 5 bytes/sec should take about a second. The old fixed
+	// 100ms grant floor completed in about 500ms.
+	if elapsed < 700*time.Millisecond {
+		t.Fatalf("too fast for very low limit: %v", elapsed)
+	}
+	if elapsed > 5*time.Second {
+		t.Fatalf("too slow for very low limit: %v", elapsed)
+	}
+}
+
 func TestOperation_read_rate_high(t *testing.T) {
 	const numbytes = (2 * 1024 * 1024 * 1024) - 1
 	l := NewLimiter(numbytes)

ticker.go

@@ -24,7 +24,9 @@ func NewTicker() (ot *Ticker) {
 // NewLimiter returns a new Limiter using this Ticker.
 // If you provide limits, the first will set
 // both read and write limits, the second will set the write limit.
-// Limits are applied in 100ms slices, so very low rates are approximate.
+// Limits are applied in 100ms slices with fractional carry-over between
+// slices, so very low rates are accurate over time but can be bursty
+// at slice boundaries.
 //
 // To stop the limiter and free it's resources, call Stop.
 func (ot *Ticker) NewLimiter(limits ...int64) (l *Limiter) {