When static makes your C code 10 times faster

Post by 8bitsrule » Mon, Jul 05, 2021, 4:52 AM UTC

rostayob wrote: post #47

95014_refugee wrote: post #46

Earlier quoted context omitted.

The perf difference was due to the compiler being able to infer 'const' by way of 'static'. Advocating 'static' when your actual intent is 'const' does less experienced readers a disservice; they will assume that 'static' is meant to make things faster, and be disappointed when it doesn't work for non-constant values.

I am not advocating static. I'm advocating for looking at what the compiler outputs when surprising behavior is encountered. The example is extracted from a larger piece of code, and I reported the minimal case as-is. If anything, the title is meant to be read as "isn't it amusing that something apparently unrelated such as `static` causes a performance improvement". That said, I have added a note clarifying this at…

Post by makapuf » Mon, Jul 05, 2021, 5:34 AM UTC

samsin wrote: post #90

gpanders wrote: post #85

Earlier quoted context omitted.

I really wish Zig had followed Rust’s lead and made variables const by default :/

Variables are immutable by default in Rust, but they're not const by default. The difference is that a variable can become mutable while a const is always immutable.

Post by nicoburns » Mon, Jul 05, 2021, 7:53 AM UTC

makapuf wrote: post #93

samsin wrote: post #90

Earlier quoted context omitted.

Variables are immutable by default in Rust, but they're not const by default. The difference is that a variable can become mutable while a const is always immutable.

How do you set a variable as mutable after the fact in rust?

    let foo = "1234".to_string();
    let mut foo = foo;
    foo = "5678";

Post by pjmlp » Mon, Jul 05, 2021, 8:19 AM UTC

rostayob wrote: post #38

GlitchMr wrote: post #37

Without `static`, compiler exports a symbol. $ cat value.c int value = 42; int get_value() { return value; } $ make value.o gcc -c -o value.o value.c $ nm value.o 0000000000000000 T get_value U _GLOBAL_OFFSET_TABLE_ 0000000000000000 D value This symbol, not being `const` can be modified by any other compilation unit. $ cat main.c #include int value; int get_value(); int main() { value = 123456789; printf("%d\n", get_…

Yes, see last few paragraphs of the post, in which I also speculate why GCC doesn't infer that there is only one compilation unit.

Post by pjmlp » Mon, Jul 05, 2021, 8:25 AM UTC

missblit wrote: post #72

einpoklum wrote: post #58

Title rephrase: When the compiler can assume your values don't change magically, it can optimize their use. This is true for restricted pointers, for global-scope variables which can only be accessed in the same translation unit, for stuff in inlined functions (often), etc. -------------------------------------------- const is a bit shifty. const makes the compiler restrict what it allows you to write, but it can sti…

Specifically it's well-defined behavior to mutate an object after const_cast-ing away constness if the object wasn't const to begin with (const references or const pointers can refer to non-const objects). In your first example you have `int x = 1;` which isn't const, so the compiler has to assume that `f` may mutate it after const casting. In your second example you have `const int x = 1;` which is const so the comp…