How to run for x seconds in a http handler

Question

I want to run my function InsertRecords for 30 seconds and test how many records I can insert in a given time.

How can I stop processing InsertRecords after x seconds and then return a result from my handler?

func benchmarkHandler(w http.ResponseWriter, r *http.Request) {

    counter := InsertRecords()

    w.WriteHeader(200)
    io.WriteString(w, fmt.Sprintf("counter is %d", counter))    
}

func InsertRecords() int {
  counter := 0
  // db code goes here
  return counter
}

Answer 1

As JimB pointed out cancelation for limiting the time taken by an http requests can be handled with context.WithTimeout, however since you asked for the purposes of benchmarking you may want to use a more direct method.

The purpose of context.Context is to allow for numerous cancelation events to occur and have the same net effect of gracefully stopping all downstream tasks. In JimB's example it's possible that some other process will cancel the context before the 30 seconds have elapsed, and this is desirable from the resource utilization point of view. For example, if the connection is terminated prematurely there is no point in doing any more work on building a response.

If benchmarking is your goal you'd want to minimized the effect of superfluous events on the code being benchmarked. Here is an example of how to do that:

func InsertRecords() int {

    stop := make(chan struct{})
    defer close(stop)

    countChan := make(chan int)
    go func() {
        defer close(countChan)
        for {

            // db code goes here

            select {
            case countChan <- 1:
            case <-stop:
                return
            }
        }
    }()

    var counter int
    timeoutCh := time.After(30 * time.Second)
    for {
        select {
        case n := <-countChan:
            counter += n
        case <-timeoutCh:
            return counter
        }
    }

}

Essentially what we are doing is creating an infinite loop over discrete db operations, and counting iterations through the loop, we stop when time.After is triggered.

A problem in JimB's example is that despite checking ctx.Done() in the loop the loop can still block if the "db code" blocks. This is because ctx.Done() is only evaluated inline with the "db code" block.

To avoid this problem we separate the timing function and the benchmarking loop so that nothing can prevent us from receiving the timeout event when it occurs. Once the time out even occurs we immediately return the result of the counter. The "db code" may still be in mid execution but InsertRecords will exit and return its results anyway.

If the "db code" is in mid-execution when InsertRecords exits, the goroutine will be left running, so to clean this up we defer close(stop) so that on function exit we'll be sure to signal the goroutine to exit on the next iteration. When the goroutine exits, it cleans up the channel it was using to send the count.

As a general pattern the above is an example of how you can get precise timing in Go without regard to the actual execution time of the code being timed.

sidenote: A somewhat more advanced observation is that my example does not attempt to synchronize the start times between the timer and the goroutine. It seemed a bit pedantic to address that issue here. However, you can easily synchronize the two threads by creating a channel that blocks the main thread until the goroutine closes it just before starting the loop.

Answer 2

Cancellations and timeouts are often done with a context.Context.

While this simple example could be done with a channel alone, using the context here makes it more flexible, and can take into account the client disconnecting as well.

func benchmarkHandler(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
    defer cancel()

    counter := InsertRecords(ctx)

    w.WriteHeader(200)
    io.WriteString(w, fmt.Sprintf("counter is %d", counter))
}

func InsertRecords(ctx context.Context) int {
    counter := 0
    done := ctx.Done()
    for {
        select {
        case <-done:
            return counter
        default:
        }

        // db code goes here
        counter++
    }
    return counter
}

This will run for at least 30 seconds, returning the number of complete database iterations. If you want to be sure that the handler always returns immediately after 30s, even if the DB call is blocked, then you need to push the DB code into another goroutine and let it return later. The shortest example would be to use a similar pattern as above, but synchronize access to the counter variable, since it could be written by the DB loop while returning.

func InsertRecords(ctx context.Context) int {
    counter := int64(0)
    done := ctx.Done()

    go func() {
        for {
            select {
            case <-done:
                return
            default:
            }

            // db code goes here
            atomic.AddInt64(&counter, 1)
        }
    }()

    <-done
    return int(atomic.LoadInt64(&counter))
}

See @JoshuaKolden's answer for an example with a producer and a timeout, which could also be combined with the existing request context.