multiple-precision | 長野高専の3J「アルゴリズムとデータ構造」後期の多倍長演算プログラム

I'm working on a native C++/CLI class which performs integer arithmetic with multiple-precision values. Individual integers are represented by arrays of 64-bit unsigned integers. The sign is represented by a boolean value, negative values are stored with their absolute values, not as two's complements. This makes dealing with sign issues much easier. Currently I'm optimizing the multiplication operation. I've already done several optimization rounds, but still my function requires twice the time of the * operator of two .NET BigInteger values, which shows that there's still considerable potential for further optimization.

Before asking for help, let me show you what I've already tried. My first attempt was a naive approach: Multiply pairs of all 64-bit items using an elementary 64-to-128-bit multiplication, and shift/add the results. I don't show the code here, because it was terribly slow. The next attempt was a recursive divide-and-conquer algorithm, which turned out to be much better. In my implementation, both operands are split recursively in the middle, until two 64-bit values remain. These are multiplied yielding a 128-bit result. The collected elementary results are shift/added all the way up the recursion layers to yield the final result. This algorithm probably benefits from the fact that much less 64-to-128-bit elementary products need to be computed, which seems to be the main bottleneck.

So here's my code. The first snippet shows the top-level entry point: