Go Performance: Function Parameters vs. Global Variables: Is There a Real Speed Difference?

Performance Implications of Function Parameters vs. Global Variables

In the realm of Go programming, the question often arises: should function parameters be prioritized over global variables for optimal performance?

Consider the function checkFiles which takes a slice of excluded patterns as an argument:

func checkFiles(path string, excludedPatterns []string) {
    // ...
}

Since excludedPatterns remains constant throughout the function's execution, some may suggest making it a global variable to optimize performance by eliminating the repeated parameter passing.

However, this optimization is unnecessary in Go due to its efficient handling of slice parameters. Slices are lightweight structures that contain metadata (length and capacity) and point to an underlying data structure. When a slice is passed as a function parameter, only the metadata is copied, not the entire backing array. This is known as "copy-on-write" semantics. Therefore, accessing excludedPatterns via a function parameter is equally efficient as accessing it as a global variable.

Furthermore, passing parameters by value can often lead to optimizations by the compiler, such as caching. Global variables, on the other hand, require more complex handling, which can potentially hinder optimization.

Benchmarks illustrate that there is no significant performance difference between passing a slice as a function parameter and accessing a global slice:

package main

import (
    "testing"
)

var gslice = make([]string, 1000)

func global(s string) {
    for i := 0; i < 100; i++ {
        _ = s
        _ = gslice // Access global-slice
    }
}

func param(s string, ss []string) {
    for i := 0; i < 100; i++ {
        _ = s
        _ = ss // Access parameter-slice
    }
}

func BenchmarkParameter(b *testing.B) {
    for i := 0; i < b.N; i++ {
        param("hi", gslice)
    }
}

func BenchmarkGlobal(b *testing.B) {
    for i := 0; i < b.N; i++ {
        global("hi")
    }
}

func main() {
    testing.Main(m.Run, m.init, m.cleanup, m.installFlags)
}

Benchmark results indicate that both approaches perform at nearly identical speeds:

BenchmarkParameter-8   20000000                80.2 ns/op
BenchmarkGlobal-8     20000000                79.9 ns/op

In conclusion, for the use case in question, passing excludedPatterns as a function parameter is recommended as it simplifies code, enhances readability, and offers comparable performance to global variables in Go.

The above is the detailed content of Go Performance: Function Parameters vs. Global Variables: Is There a Real Speed Difference?. For more information, please follow other related articles on the PHP Chinese website!