3

I have a function which is doing some operation on array inside loop. After every iteration it is supposed to initialize the array to zero. So which of the following will give a performance benefit?

one.c

int main(void){
 char buf[4096] = { 0};

 while (1 /*flag*/) {

       /*Some operation here*/
    memset (buf, 0, sizeof (buf));
    }
}

two.c

int main(void){

 while (1 /*flag*/) {
       char buf[4096] = { 0};
       /*Some operation here*/
    }
}

In one.c explicit memset is used. But in two.c array is declared inside the loop and initialized to zero.

Improve this question
6
  • 1
    one.c is better choice. there same variable memory is set and unset but in case of two.c you are creating loop time buf Commented Oct 24, 2014 at 4:37
  • memset is a better option as it has a pre-defined behavior by included in string.h library that it reset entire memory block to zero whereas declaring a stack variable in loop causes the program to initialize the array in each iteration which is more costly then resetting memory location. Commented Oct 24, 2014 at 4:53
  • 1
    @Rustam actually, no. Any production-level compiler will optimize the second version so that it uses the same (amount of) memory. However, minimizing the scope of variables is generally a good idea, so I would go with two.c. Commented Oct 24, 2014 at 4:54
  • 2
    @AunnRaza ugh, that's pretty much entirely incorrect. memset is not magic. It has to go over all the memory that you want to zero. Semantically, it's equivalent with the re-initialization. (It's possible that the re-initialization is implemented by the compiler as memset or vice-versa). Your "nitialize the array in each iteration which is more costly then resetting memory location" simply makes no sense at all. Commented Oct 24, 2014 at 4:56
  • @Rustam: additionally, because of the initializer in the variable definition in one.c, there is an extra 4 KiB memory initialization. If the variable was not explicitly initialized in one.c, then the two would be equivalent. Commented Oct 24, 2014 at 5:09

3 Answers 3

Reset to default
4

Ugh. I see a lot of speculation going on. Let's see:

First of all, ask yourself: does performance even matter? IOW,

  • have you benchmarked your program?
  • did it turn out to be slow because of calling memset or the initialization?
  • did changing it to the other alternative result in significant performance improvement?

I would guess that you haven't benchmarked it yet, in which case you definitely should. Or maybe performance is not really important here, in which case you should go with the stylistically superior one.

In general, however, there are a few things that can be said about this code. Note that this is all speculation, since I don't know what you are doing in the loop and thus can't reproduce your code and benchmark it, but I would.

First of all, I prefer the second version because it minimizes the scope of the buffer. Generally, you want to minimize the lifetime of variables so as to:

  1. minimize the probability of variable name collisions or accidentally re-using variables, and
  2. let the compiler's optimizer re-use their storage for other variables in order to minimize stack usage.

Additionally, today's aggressively-optimizing compilers will most probably treat both pieces of code identically. memset() is usually a compiler intrinsic function, so the compiler knows its semantics (i. e. that it fills memory with bytes). So, the compiler may inline the call to memset() and just emit code that zeroes out the memory if it turns out to be faster to do so, so there's no function call overhead.

The inverse decision can be made too: if the compiler deduces that it's better for some reason (i. e. reduced code size) to call a function, then it can substitute the byte-by-byte zero-initialization of the array to a call of memset(), and often it does indeed.

The argument I've read in some answers/comments that "initializing the array is more costly than resetting memory location" is simply nonsense -- I don't even understand what is meant by "resetting memory location". Both zero-initialization and memcpy(0) do the very same thing in this scenario, and chances are, if you compile with enough optimizations enabled, they will compile to the exact same machine code.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

3

These are both exactly the same. In fact both programs could be fully optimized out since none produces any observable behaviour.

If your compiler (at maximum optimization level) does something differently for either program then could report it to your compiler vendor, and also use whichever one seems to be faster based on testing in your environment.

There is no global answer to "what is faster".

Link to example code where I added in some cruft to inhibit optimization - func1 and func2 bodies look pretty similar.

Improve this answer

Comments

2

both of them use same size of stack (4KB) to store the buffer, however, in the looping, two.c will not call a function, it directly store 0 to buf, typically use instruction stos, so, if one.c is not optimized enough, two.c seems have better performance.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.