compiler-optimization

We have a lot of code which is usable in any iOS application we write. Things such as: Custom/Common Controls Extensions on common objects like UIView, UIImage and UIViewController Global utility functions Global constants Related sets of files that make up common 'features' like a picker screen that can be used with anything that can be enumerated. For reasons unrelated to this question, we cannot use static or dynamic libraries. These must be included in the project as actual source files. There are several hundred of these 'core' files so what I've been doing is adding all the files to the

I would like to create a function that always returns zero, but this fact should not be obvious to the optimizer, so that subsequent calculations using the value won't constant-fold away due to the "known zero" status. In the absence of link-time optimization, this is generally as simple as putting this in its own compilation unit: int zero() { return 0; } The optimizer can't see across units, so the always-zero nature of this function won't be discovered. However, I need something that works with LTO and with as many possible future clever optimizations as well. I considered reading from a

One of the goals of C++ is to allow user-defined types to behave as nicely as built-in types. One place where this seems to fail is in compiler optimization. If we assume that a const nonvolatile member function is the moral equivalent of a read (for a user-defined type), then why not allow a compiler to eliminate repeated calls to such a function? For example class C { ... public: int get() const; } int main() { C c; int x{c.get()}; x = c.get(); // why not allow the compiler to eliminate this call } The argument for allowing this is the same as the argument for copy elision: while it changes

While reading this question , I've seen the first comment saying that: size_t for length is not a great idea, the proper types are signed ones for optimization/UB reasons. followed by another comment supporting the reasoning. Is it true? The question is important, because if I were to write e.g. a matrix library, the image dimensions could be size_t , just to avoid checking if they are negative. But then all loops would naturally use size_t . Could this impact on optimization? size_t being unsigned is mostly an historical accident - if your world is 16 bit, going from 32767 to 65535 maximum

Nowadays, super-scalar RISC cpus usually support out-of-order execution, with branch prediction and speculative execution. They schedule work dynamically. What's the advantage of compiler instruction scheduling, compared to an out-of-order CPU's dynamic scheduling? Does compile-time static scheduling matter at all for an out-of-order CPU, or only for simple in-order CPUs? It seems currently most software instruction scheduling work focuses on VLIW or simple CPUs. The GCC wiki's scheduling page also shows not much interest in updating gcc's scheduling algorithms. Advantage of static (compiler)

I was reading about hash functions (i'm an intermediate CS student) and came across this: int hash (const string & key, int tableSize) { int hasVal = 0; for (int i = 0; i < key.length(); i++) hashVal = 37 * hashVal + key[i]; ..... return hashVal; } I was looking at this code and noticed that it would be faster if in the for-loop instead of calling key.length() each time we instead did this: int n = key.length(); for (int i = 0; i < n; i++) My question is, since this is such an obvious way to slightly improve performance does the compiler automatically do this for us? I don't yet know much

Most C++ programmers know about the empty base class optimazation as a technique / idiom . What happens with empty child classes? For example class EmptyBase { int i; }; template<typename T> class Derived : T { }; std::cout << sizeof(Derived<EmptyBase>); // Is there a standard verdic on this? Similarly to the EBO there should be an EDO stating that since a derived class doesn't provide any more members, nor introduces any virtual ones to its parametrizing type , it should not require more memory. Considering the various situations in which something like that might apper (multiple inheritance,