Go Performance: Is Passing Slices as Parameters or Using Global Variables Faster?

Performance Implications of Function Parameters vs Global Variables

When optimizing performance in Go, one may consider passing parameters as function arguments instead of accessing global variables for reasons of efficiency. However, the impact of such an approach can vary depending on the situation.

In the case of the presented checkFiles function, with a fixed excludedPatterns slice, one might question if making it a global variable (rather than passing it as an argument) would enhance performance. However, it's important to note that performance is unlikely to be significantly impacted due to the efficiency of passing slices in Go.

Slices are essentially lightweight descriptors comprising a pointer to an underlying array along with length and capacity values. Regardless of the array's size, passing slices is highly efficient. Passing pointers to slices is generally not recommended unless one intends to modify the slice header.

Parameters in Go are invariably passed by value, meaning a copy of the value is passed to the function. When a pointer is passed, only its value (i.e., the address) is copied. In the case of slices, passing the slice value (the descriptor) creates a copy that points to the same underlying array, avoiding any need to copy the array.

Moreover, using parameters often presents additional benefits. For example, it allows compilers to optimize and cache more efficiently, whereas global variables necessitate greater caution.

To assess the performance difference precisely, one can conduct benchmarking. The provided code demonstrates that there is negligible difference in performance between passing a slice as an argument and accessing a global slice in the function:

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")
    }
}

Running the benchmark reveals that both methods perform similarly in terms of execution time.

Therefore, while considering performance optimization techniques, it is essential to understand the specifics of the situation and to benchmark the code to measure the actual impact of any changes made.

The above is the detailed content of Go Performance: Is Passing Slices as Parameters or Using Global Variables Faster?. For more information, please follow other related articles on the PHP Chinese website!