Question

As far as I understood it, BigInts are usually implemented in most programming languages as arrays containing digits, where, eg.: when adding two of them, each digit is added one after another like we know it from school, e.g.:

 246
 816
 * *
----
1062

Where * marks that there was an overflow. I learned it this way at school and all BigInt adding functions I’ve implemented work similar to the example above.

So we all know that our processors can only natively manage ints from 0 to 2^32 / 2^64.

That means that most scripting languages in order to be high-level and offer arithmetics with big integers, have to implement/use BigInt libraries that work with integers as arrays like above.
But of course this means that they’ll be far slower than the processor.

So what I’ve asked myself is:

• Why doesn’t my processor have a built-in BigInt function?

It would work like any other BigInt library, only (a lot) faster and at a lower level: Processor fetches one digit from the cache/RAM, adds it, and writes the result back again.

Seems like a fine idea to me, so why isn’t there something like that?

Answer 1

There are simply too many issues that require the processor to deal with a ton of stuff which isn’t its job.

Suppose that the processor DID have that feature. We can work out a system where we know how many bytes are used by a given BigInt – just use the same principle as most string libraries and record the length.

But what would happen if the result of a BigInt operation exceeded the amount of space reserved?

There are two options:

1. It’ll wrap around inside the space it does have
   or
2. It’ll use more memory.

The thing is, if it did 1), then it’s useless – you’d have to know how much space was required beforehand, and that’s part of the reason you’d want to use a BigInt – so you’re not limited by those things.

If it did 2), then it’ll have to allocate that memory somehow. Memory allocation is not done in the same way across OSes, but even if it were, it would still have to update all pointers to the old value. How would it know what were pointers to the value, and what were simply integer values containing the same value as the memory address in question?