Security/performance implications of malloc over calloc?

Question

According to the Linux man page, the difference between calloc and malloc is that malloc does not initialize the memory, while calloc does initialize the memory.

What that means in practice is that if I create a struct like this:

struct Danger {
    char a;
    char b;
    char c;
    char d;
}

If I create it with malloc:

struct Danger *dang = malloc(sizeof(struct Danger));

It seems that dang->a could really be any value at this point, as the memory isn't initialized. If I use calloc:

struct Danger *dang = calloc(1, sizeof(struct Danger));

I know now that dang->a must equal \0.

The reason malloc presumably exists is in the case that you'll be writing to the entire memory space you've allocated immediately, you don't really care about what's in there at first. This saves you an extra step of zeroing out the data which will be overwritten anyway

It seems though, that from a program security and stability point of view, using malloc should be the exception rather than the rule, as it can easily lead to undefined behavior.

Two questions:

• Do C programs in the wild deal with unexpected functionality as a result of malloc often? Is this a fairly recurrent problem?
• How much of a performance penalty do I really get if I just use calloc every time instead of malloc?

Answer 1

Do C programs in the wild deal with unexpected functionality as a result of malloc often? Is this a fairly recurrent problem?

They deal with the "problem" often, but usually in the way that they try not to read the junk data. This is usually no problem, because the data needs to be initialized anyway. The real danger lies in unintentially reading junk/zero data, which cannot be ruled out by using calloc().

There are ways to ensure that a program does not read junk data. The easiest is to just execute the test suite with valgrind. It reports any reading of junk data. It will also catch any use-after-free errors, accesses of unallocated memory, lost memory blocks, etc.

How much of a performance penalty do I really get if I just use calloc every time instead of malloc?

Precisely the overhead of writing the writing the data twice. It might remove some valuable data from the cache, so it really depends on how big the memory block is, and the sequence of operations that you use afterwards to fill it with sensible data.

• Worst case: The zeroing evicts data from the cache that you need to fill the memory block. This data needs to be reloaded from memory which is the main part of the performance impact. For a memory block in the order of some megabytes, this can amount to an impact in the order of some 100 microseconds. Details depend on your machine.

• Best case: You fill a small memory block right after allocating it without reading any data. In this case the overhead is simply that of writing the data to first level cache. Even though this is a fast operation, you can still expect the zeroing to take the same time as your own initialization - cache is not infinitely fast.

---

Pesonally, I only use calloc() as a convenient way to get a zero initialized block when I need a zero initialized block. Which is usually not the case. But it happens from time to time.