What is the fastest, most memory-saving type?

Question

I am making a game of navinha in C, and therefore need to put in a vector a large amount of projectiles.

These projectiles have at least one position and speed to make calculations, and I’m trying to decide how best to store them in memory for later use.

So there are some questions:

What is the fastest C language type for calculations on modern processors? Which faster type causes less mess in the alignment of a structure and wastes less memory?

This includes variations of types (not int vs float, but also int8_t, uint_fast32_t, double, long double, etc...)

Answer 1

If you are storing this data in a contiguous region of memory (e.g., an array), then using the type with the smallest size that still "fits" your data would have the best performance. In modern processors, the bottleneck is not in the instructions, but in the cache: one miss cache in L1 "wastes" 10-40 cycles, in L2 more than 600. If you can reduce the number of Misses [by using less memory] at the expense of an additional operation or two (e.g.: types that do not align perfectly in memory, simple conversion of int for float), global performance will be greater.

Disclaimer: I gave my answer based on my theoretical knowledge, but I have not tested it in practice. I cannot say precisely what is the overhead of the above type conversions, and anyway real systems tend to behave surprisingly many times...

Answer 2

First of all, be careful not to make premature optimizations because it is very easy to write a complex and "optimized" program that is actually slower than a simpler and more intuitive program. When in doubt use int even is go take care of performance only when you identify a bottleneck in your tests.

---

But for a more complete answer, the most important thing to keep in mind when choosing an integer type are the rules of coercion when you convert from one type to the other and the rules of what happens in case of overflow (very large or small numbers)

• For local variables and parameters and function return values prefer to use int. This will compile to use the whole type and "standard" arithmetic operations of your machine.

  This is true even if you are doing math with characters. Not only can you use EOF without overflowing, but you avoid creating a lot of extra instructions to truncate the intermediate values of the accounts back to 8 bits. For example, note how the isalpha functions, etc, of the standard library receive int parameters instead of char.

• Numbers unsigned are useful if you want well-defined overflow behavior (wrap-Around) or if you are working with bit masks. Otherwise, avoid using them, even if you know that the value that interests you is always positive. -1 give underflow is a source of a lot of headache (eg, for(unsigned i=N; i>=0; i--) becomes an infinite loop).

• If you are storing a lot of values in a vector the width of the integers gains more importance (a char vector spends far less space than an int vector) and the performance of operations is less important (You will extract these values to a local registrar/variable before doing any accounts on them).

• Avoid fixed size types like int8_t etc unless you are doing something that requires an entire exactly that size. Not only are these types full of extra Casts (see the previous example of int vs char) but these Casts can be more expensive if the size is not something common in your architecture.

• If the values of your integers can be very large, at a point where 32-bit or 64-bit makes a difference you have to be more careful. There is more than one alternative you can use (long long, bignum library, vector of smaller integers, etc.) and the best solution will depend on your problem, compiler, etc.

Answer 3

In this case, it’s not the question of faster, but the question of which kind makes the most sense.

In general, working with integers will always be more efficient than working with letters, but from a programming point of view, unless you are working with something that requires extreme performance, it is best to use what is most comfortable.

In C, when it makes sense, it is useful for example to use struct for more complex data instead of just using an array with vectors. A struct, for example, can store information like the last data accessed from a list of an array (or linked list) and, as not as efficient as using pure data, can be extremely efficient when the amount of data is greater, because you would have already curled the die, instead of having to sweep the entire list looking for the data you wanted.

Okay, you really want to know which one is faster? Well, when in doubt, it’s usually faster data than occupying less data in memory, or data that can be operated by bitwise operations. Even in this case, it is not only the data that matters, but how the data will be used.

Answer 4

For integer numbers, the most indicated always the word size number of the processor. It will align right in memory everything else. Since this changes from compiler to compiler, the most guaranteed is to use ptrdiff_t and size_t, Standard typedefs for whole types with and without signal respectively, defined in stddef.h. Already to floating point, there is no reason not to use double. In any modern processor it is efficient, and it is not justified to use the float.