c 中全局变量的性能影响

Question

I have 5 functions which gets called 10000+ times (on an average). All of them modifies/uses certain variables.

I know it is bad practice to have global variables. But for performance sake, does it make sense to keep them global and not pass them around - specially when I am making function call these many times?

OR I am not going to gain much in terms of performance?

Answer 1

Do not introduce global variables/global state for performance purposes. This is misguided, contrary to all good coding practices, and usually will not help performance (it might even hurt).

If you're finding it too costly to pass around lots of variables, you can put them all in a context struct and pass a single pointer to the struct . This way you avoid creating global state (even static storage duration variables are global state) which prevents your code from being usable in multiple instances. The cost is virtually zero, and in fact it will be less costly than global variables in position-independent code (shared libraries or position-independent executables).

Answer 2

You may see a small performance improvement by reducing the number of parameters that are passed to your functions, by pre-allocating variables (eg. global or static variables)

The change in performance is absolutely going to depend on a number of things, not the least of which is the platform that you're developing on. If you're developing for a tiny microprocessor the time taken to copy parameters onto the stack (from the calling function) and the time taken to access the stack may be a significant enough proportion of the total execution time to warrant it.

Note that in the situation where the time taken to pass parameters is significant you may find that some of the other suggestions (eg. passing pointers to structures, passing pointers to static variables) will not provide any benefit either. Using global variables does give the compiler/linker the opportunity to hard code access to those variables rather than having to access them indirectly from a pointer on the stack. This is particularly pertinent to processors that don't have any cache.

Of course this is all very target dependent, and highly dependent on the instruction set of the processor that you're using. On any platform with a reasonable instruction set you should see an improvement.

However, measures like this should only be taken after profiling this code. On most platforms, with any non-trivial function, the time taken to pass the parameters and access them is insignificant. Any potential performance gain would come at the cost of more difficult maintenance of the code.

It is very likely that you would achieve greater performance gains by using other optimisation techniques. Check this question for some methods to try.

---

Edit: I see from one of your comments that you are still in the design phase of this project.

It is too early in the process to be making optimisations like this. At this stage you'll have a far greater impact on performance by optimising the algorithms you use than minimising at the instruction level like this.

Answer 3

static variables is C have file scope, and they might be sufficient in your case - provided you can group your functions into 1 file. And for me static variables are several orders of magnitude less problematic than globals.

One often overlooked issue is that variables declared inside a function body will be allocated on the stack, whereas static variables are typically allocated from a less confined memory pool called bss.So, having all variables neatly defined inside functions can lead to stack exhaustion problems, and that can be avoided in a quite clean way with statics.

Answer 4

I would go as far as saying that global variables will probably be slower than passing parameters. Parameters live on the stack which is heavily used and will therefore most likely be in cache. Global variables live in static space which is used a lot less and therefore less likely to be in cache making memory lookups a lot slower. Due to caching considerations, your jump (to the new function) may well be the slowest part of the whole function call operation.

If your functions are small,look at inlining them. If they are big, chances are that pushing one or two words on the stack will make minimal difference.

Also note that use of the stack for parameter passing is very much an x86 thing. ARM and other architectures that have a large number of registers will normally used some registers for param passing that is extremely fast.

Answer 5

On some embedded microcontrollers , there may be performance advantages to using global variables instead of parameters, but this is highly machine-dependent .

When using a typical 8-bit microcontroller compiler (HT-PICC18), for example, the cost of setting a global variable is two instructions/two cycles per byte. Passing one single-byte parameters costs instruction/one cycle. Passing two or more bytes of parameters cost two cycles per byte. Thus, the most efficient way to pass two single-byte parameters is to pass one as a parameter and one as a global.

On an Introl compiler for the 68HC11, routines which have any auto variables or parameters require a multi-instruction prologue and epilogue which can be omitted if all variables are static and parameters are passed as globals. If a routine will use any locals or parameters, however, the marginal cost of using locals and parameters for everything else is negligible.

On the ARM, even without a cache, the reverse situation often applies: accessing auto variables or parameters will often be faster than accessing global variables. The auto variables and parameters will either be in a register, or else will be at a directly-accessible known offset from an address stored in a register. Accessing global variables, by contrast, will often be a two-step process: first load the address of the global variable, and then access the variable itself.

Answer 6

People generally try to stay away from global parameters unless they really need them (ie unless something genuinely has global state). Especially for multi-threaded applications the use of global parameters can make things more difficult than they need to be.

In terms of performance, I have heard a few people imply that access to global variables could be faster in some cases, although I find it hard to believe, but the only way to be sure is to actually do some benchmarking for you particular case.

Personally, I would never do this. I would think about the way that parameters were passed to the functions (make sure it's by pointer, rather than by copy, for instance, in the case of large data types) and ensure that the correct (best) optimisation settings were being passed to the compiler.

Hope this helps.

Answer 7

I think you're not going to improve performances by replacing parameters with global variables.

Anyway if you wanna do this you can also consider to declare all functions and variables in the same file and declare variables as static. In that way only functions declared in the same file can access them.

See here