Passing arguments to functions with const parameters: is it faster?

Question

Consider, for example:

int sum(int a, int b)
{
    return a + b;
}

vs.

int sum(const int a, const int b)
{
    return a + b;
}

Is the second approach in general faster?

Function parameters in C are copied and sent to the function, so that changes inside the function do not affect the original values. My reasoning is that in the second sum above, the compiler knows for sure that a and b are not modified inside the function, so it can just pass the original values without copying them first. That's why I think the second sum is faster than the first. But I don't really know. In the particular simple example of sum above, the differences, if any, should be minimal.

Edit: The sum example is just to illustrate my point. I don't expect that in this particular example there should be large differences. But I wonder if in more complicated situations the const modifier inside a function parameter can be exploited by the compiler to make the function faster. I doubt that the compiler can always determine whether a parameter is changed inside a function (hence my 2nd question below); hence I'd expect that when it finds a const modifier, it does something different than when there's no const modifier.

Question: In general, a function will be faster when its arguments are const, than when they are not?

Question 2: In general, can a C compiler (theoretically) always determine whether a function parameter is changed inside the function?

The compiler, however, knows very well a and b are left unmodified in both versions, so whatever optimizations it could apply... — eq-
– eq-, Commented Sep 6, 2012 at 0:53
Look at the generated assembly to see if there's any difference. (There probably isn't). — Blastfurnace
– Blastfurnace, Commented Sep 6, 2012 at 0:54
@Blastfurnace gcc 4.5.2 generates exact same assembly codes. — shinkou
– shinkou, Commented Sep 6, 2012 at 0:58
@Blastfurnace: +1. And of course, don't forget to test it with optimizations flags. Probably, by using const will be written on read-only memory, which normally is faster. — Jack
– Jack, Commented Sep 6, 2012 at 1:04

Richard J. Ross III · Accepted Answer · 2012-09-06 01:15:37Z

16

Short answer: No

Long answer, no, with proof.

I ran this test, a couple of times, and saw no real time difference, on my MacBook pro compiled with clang:

int add(int a, int b)
{
    return a + b;
}

const int cadd(const int a, const int b)
{
    return a + b;
}

int main (int argc, char * argv[])
{
#define ITERS 1000000000

    clock_t start = clock();
    int j = 0;
    for (int i = 0; i < ITERS; i++)
    {
        j += add(i, i + 1);
    }

    printf("add took %li ticks\n", clock() - start);

    start = clock();
    j = 0;
    for (int i = 0; i < ITERS; i++)
    {
        j += cadd(i, i + 1);
    }

    printf("cadd took %li ticks\n", clock() - start);

    return 0;
}

Output

add took 4875711 ticks
cadd took 4885519 ticks

These times really should be taken with a grain of salt, however, as clock isn't the most accurate of timing functions, and can be influenced by other running programs.

So, here is the compared assembly generated:

_add:
    .cfi_startproc
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register %rbp
    movl    %edi, -4(%rbp)
    movl    %esi, -8(%rbp)
    movl    -4(%rbp), %esi
    addl    -8(%rbp), %esi
    movl    %esi, %eax
    popq    %rbp
    ret

_cadd:                                 
    .cfi_startproc    
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register %rbp
    movl    %edi, -4(%rbp)
    movl    %esi, -8(%rbp)
    movl    -4(%rbp), %esi
    addl    -8(%rbp), %esi
    movl    %esi, %eax
    popq    %rb

So, as you can see, there is No difference between the two. Passing an argument as const is only a hint to the caller the the argument will not be changed, and in a simple scenario like the one described above, will not result in any different assembly compiled.

answered Sep 6, 2012 at 1:15

Richard J. Ross III

55.7k25 gold badges139 silver badges205 bronze badges

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

6 Comments

David Grayson Over a year ago

I would not consider this to be a "proof". Sure, it proves it for your particular architecture, compiler, and optimization settings, but the OP's question is a general one about C. Also, you didn't tell us what architecture, compiler, and optimization settings you are using.

Richard J. Ross III Over a year ago

@DavidGrayson I'm using a macbook pro, so It's 64bit, clang, and no optimization (-O0).

a06e Over a year ago

@RichardJ.RossIII +1, But you are using no optimization. I would like to see what happens if you let the compiler do optimization.

Richard J. Ross III Over a year ago

@becko I'd assume that it would inline the functions, which makes the test moot.

a06e Over a year ago

@RichardJ.RossIII Could one disable only inlining, but retain all other optimizations? The point of my question is whether const function arguments allow the compiler to do more optimizations.

|

David Grayson · Accepted Answer · 2012-09-06 00:54:43Z

9

The answer probably depends on your compiler, the optimization level, and whether the compiler decides to inline the function. If you are curious about these things, it is easy to just look at the actual assembly produced by your compiler and find out.

answered Sep 6, 2012 at 0:54

David Grayson

88.1k24 gold badges159 silver badges195 bronze badges

3 Comments

David Grayson Over a year ago

It probably depends on whether the function is static or not too; the compiler has more freedom to change/inline a static function because it knows it will not be called from other files.

a06e Over a year ago

+1 I am using Visual Studio 2010. I'll try to look at the assembly code generated, as suggested by @Blastfurnace, and see if there's any difference.

Chucky Over a year ago

Please, avoid terms like "it is easy to" as it can actually be for some but not for others. An octopus finds it easy to open 2 cans at the same time but I don't. Moreover, getting the disassembled code can be tricky with some development environments.

RolandXu · Accepted Answer · 2012-09-06 00:59:27Z

0

No. both of them should be same speed. for your reason, assume it passes the original values in to sum function, how about some code out of the sum function modify the original value, for example, another thread.

In general, the const has no impact the performance at arguments. it do impact the performance if the const is a local/global variable because some calculation can be moved to compiling time as if it is a const.

answered Sep 6, 2012 at 0:59

RolandXu

3,6982 gold badges19 silver badges23 bronze badges

Comments

Jamey Kirby · Accepted Answer · 2017-03-31 20:23:26Z

0

Although late to the party, a compiler could put variables defined as const in a read-only memory segment/block, so that if an attempt was made to write to the address, via some pointer tomfoolery, the write to the memory would trigger an exception at runtime.

-- Jamey

answered Mar 31, 2017 at 20:23

Jamey Kirby

1532 silver badges6 bronze badges

3 Comments

Ethan T Over a year ago

This check happens at compile-time, not runtime. A runtime memory-write prohibition would require extra assembly and time that the compiler will not add.

Anton Shepelev Over a year ago

@Jamey Kirby, this is true of variables, but not of function arguments.

ivand58 Over a year ago

1. By default the arguments are located in the stack. 2. the cosnt keyword do not change the location!

Collectives™ on Stack Overflow

Passing arguments to functions with const parameters: is it faster?

4 Answers 4

6 Comments

3 Comments

Comments

3 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

6 Comments

3 Comments

Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related