[OT] The Usual Arithmetic Confusions
Ola Fosheim Grøstad
ola.fosheim.grostad at gmail.com
Sun Jan 30 10:51:28 UTC 2022
On Saturday, 29 January 2022 at 12:23:28 UTC, Siarhei Siamashka
> performance disadvantages compared to `a[i]`. My guess is that
> the D language design in this alternative reality would define
> arrays indexing as a modular operation and consider the "memory
> safety" goal perfectly achieved (no out of bounds accesses,
Yes, the focus on memory safety is too narrow and can be counter
> I'm not sure if I can fully agree with that. Correctness is a
> major concern in C++.
It is a concern, but the driving force for switching from
unsigned int to signed int appears to be more about enabling
optimization. At least that is my impression.
Another issue is that having multiple integer types can lead to
multiple instances of templates, which is kinda pointless.
> My understanding is that the primary source of unsigned types
> in applications is (or at least used to be) the `size_t` type.
> Which exists, because a memory buffer may technically span over
> more than half of the address space, at least on a 32-bit
Yes, *sizeof* returns *size_t* which is unsigned. I think that
has more to do with history than practical programming. But
there is no reason for modern containers to return unsigned (or
rather modular ints). Well, other than being consistent with STL,
but not sure why that would be important.
>> This is something that D should fix!!
> Do you have a good suggestion?
How many programs rely on signed wrap-over? Probably none. You
could just make a breaking change and provide a compiler flag for
getting the old behaviour? Then another compiler flag for
trapping on overflow.
> We lost this transparency a long time ago. Compilers are
> allowed to optimize out big parts of expressions. Integer
> divisions by a constant are replaced by multiplications and
> shifts, etc. Functions are inlined, loops are unrolled and/or
But you can control most of those by hints in the source-code or
There is a big difference between optimizations that lead to
faster code (or at least code with consistent performance) and
code gen that leads to uneven performance. Sometimes hardware is
bad at consistent performance too, like computations with float
values near zero (denormal numbers), and that is very unpopular
among realtime/audio-programmers. You don't want the compiler to
add more such issues.
> Well, the reality is that this is not just a theoretical
> discussion anymore. Trapping of arithmetic overflows already
> exists in the existing programming languages. And programming
> languages will keep evolving to handle it even better in the
Yes, but trapping overflows have always existed in languages
geared towards higher level programming. C and its descendants
are the outliers.
It is true though that processor speed and branch-prediction has
made it more attractive also for those that aim at lower level
The best solution for a modern language is probably to:
1. Improve the type system so that the compiler more often can
prove that overflow never can happen for an expression. This can
also lead to better optimizations.
2. Make signed overflow checks the default, but provide an inline
annotation to disable it.
I think in general that optimizing all code paths for performance
is kinda pointless. Usually critical performance is limited to a
smaller set of functions.
More information about the Digitalmars-d