Practical cases of performance testing in Golang

Practical cases of performance testing in Golang

With the widespread application of Golang in the Internet industry, the demand for code performance optimization has become increasingly prominent. Performance testing has become an important means of evaluating code performance. This article will use a practical case to introduce how to perform performance testing in Golang and optimize performance bottlenecks.

Case Background

Suppose we have a requirement to count the number of occurrences of all words in a file. This can be achieved through the following code:

func countWords(filename string) (map[string]int, error) {
    file, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    scanner.Split(bufio.ScanWords)

    count := make(map[string]int)
    for scanner.Scan() {
        word := scanner.Text()
        count[word]++
    }

    if err := scanner.Err(); err != nil {
        return nil, err
    }

    return count, nil
}

Performance Test

For the above code, we can use Golang’s built-in testing package to perform performance testing. The specific test function is as follows:

func BenchmarkCountWords(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _, err := countWords("/path/to/file.txt")
        if err != nil {
            b.Errorf("unexpected error: %v", err)
        }
    }
}

performs performance testing through the BenchmarkCountWords function, b.N represents the number of tests. In each test, we call the countWords function and determine whether an error occurs. If an error occurs, use b.Errorf to report the error.

Optimizing performance bottleneck

After performance testing, we found that in the case of large files, the execution time of the code is longer. The reason is that we use line-by-line scanning to read the file, and use string concatenation to count the number of occurrences of words. This implementation has lower performance with large files.

To address this performance bottleneck, we can use concurrent methods to optimize. The specific implementation is as follows:

func countWords(filename string) (map[string]int, error) {
    file, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    count := make(map[string]int)

    type result struct {
        word  string
        count int
    }

    wordCh := make(chan result)
    done := make(chan struct{})

    go func() {
        for r := range wordCh {
            count[r.word] += r.count
        }
        done <- struct{}{}
    }()

    scanner := bufio.NewScanner(file)
    scanner.Split(bufio.ScanWords)

    const numWorkers = 5
    var workersWg sync.WaitGroup
    workersWg.Add(numWorkers)

    for i := 0; i < numWorkers; i++ {
        go func() {
            defer workersWg.Done()

            for scanner.Scan() {
                word := scanner.Text()
                wordCh <- result{word: word, count: 1}
            }
        }()
    }

    go func() {
        workersWg.Wait()
        close(wordCh)
    }()

    if err := scanner.Err(); err != nil {
        return nil, err
    }

    <-done

    return count, nil
}

In the optimized code, we created numWorkers concurrent Goroutines to read the file and send the words and the number of occurrences to wordCh in the channel. At the same time, we created a new Goroutine to receive the words and occurrence times in the channel and summarize them into the count map. Through this concurrency method, the execution efficiency of the code is improved.

Perform performance test again

After concurrency optimization, we performed performance test again and found that in the case of large files, the execution time of the code was significantly shortened. Performance has been significantly improved.

Summary

Performance testing in Golang is an important means to evaluate code performance. Through the practical cases in this article, we learned how to perform performance testing in Golang and optimize performance bottlenecks. I hope it can be helpful to everyone in Golang performance optimization.

The above is the detailed content of Practical cases of performance testing in Golang. For more information, please follow other related articles on the PHP Chinese website!