I checked this and it reproduced with -O1 on gcc 8.3, so I just opened list of gcc optimization flags here and started experimenting with them one by one. It turned out that disabling only sparse conditional constant propagation with -fno-tree-ccp made the problem disappear (oh luck, I planned to test couples of flags if … Read more
Yes, it’s a bug. Specifically, it’s a bug in the new SSA optimizer introduced in VS2015 Update 3. The undocumented command line option -d2SSAOptimizer- tells the compiler backend to use the old optimizer instead, which causes the bug to not manifest. FYI, you can minimize your repro to: int main() { volatile int someVar = … Read more
Is there a way to express that the condition in the contract has no side effect, so that it is always optimized out? Not likely. It’s known that you cannot take a big collection of assertions, turn them into assumptions (via __builtin_unreachable) and expect good results (e.g. Assertions Are Pessimistic, Assumptions Are Optimistic by John … Read more
std::vector<T> is a fairly complicated class that involves dynamic allocation. While clang++ is sometimes able to elide heap allocations, it is a fairly tricky optimization and you should not rely on it. Example: int foo() { int* p = new int{5}; return *p; } foo(): # @foo() mov eax, 5 ret As an example, using … Read more
Are they not allowed to do so? Maybe, but optimization not done in this case may be due to corner functional differences. If 150 bytes of allocatable memory remain, data = malloc(100); data = realloc(data, 200); returns NULL with 100 bytes consumed (and leaked) and 50 remain. data = malloc(200); returns NULL with 0 bytes … Read more
Yes, it does, at least for the Debug call. I can’t see here if the JIT compiler also removed the evaluation of the if, but I guess it does since the equation doesn’t have any side effects. However, you are better of keeping it safe by calling Debug.WriteLineIf, which doesn’t depend on the JIT compiler … Read more
Don’t worry about the performance, it will be negligible. If you are curious about it, write some code to test the performance using Stopwatch and see. I suspect you’ll need to do a few million iterations to start seeing differences though. You can also never assume about the implementation of things, they are liable to … Read more
Well, your variables i and prevSpec_OilCons, if not used anywhere will be optimized away, but not your loop. So if your code looks like: static void Main(string[] args) { int[] TestRunTime = { 1, 2, 3 }; int i = 0; for (int j = 0; j < TestRunTime.Length; j++) { } double prevSpec_OilCons = … Read more
Or am I wrong, and compilers can figure out by themselves that the local variable is never modified? Most of the compilers are smart enough to figure this out themselves. You should rather use const for ensuring const-correctness and not for micro-optimization. const correctness lets compiler help you guard against making honest mistakes, so you … Read more
No, time spent does not count as observable behaviour to be protected by the as-if rule: [C++14: 1.8/5]: A conforming implementation executing a well-formed program shall produce the same observable behavior as one of the possible executions of the corresponding instance of the abstract machine with the same program and the same input. However, if … Read more