mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2025-06-08 05:27:14 +09:00
d2ea77c099
Before: - a separate Word element allocation of the underlying Vector<Word> was necessary for every new word in a multi-word shift - two additional temporary UnsignedBigInteger buffers were allocated and passed through, including in downstream calls (e.g. Multiplication) - an additional allocation and word shift for the carry - FIXME note seems to point to some of these issues After: - main change is in LibCrypto/BigInt/Algorithms/BitwiseOperations.cpp - one single allocation per call, using shift_left_by_n_words - only the input "number" and "output" need to be allocated by the caller - downstream calls are adapted not to allocate or pass temporary buffers - noticeable performance improvement when running TestBigInteger: 0.41-0.42s (before) to 0.28-0.29s (after) Intel Core i9 laptop Bonus: remove unused variables from UnsignedBigInteger::divided_by - These were likely cut-and-paste artifacts from UnsignedBigInteger::multiplied_by; not caught by "unused-varible". NOTE: making this change in a separate commit than shift_right, even if it touches the same file BitwiseOperations.cpp since: - it is a "bonus" addition: not necessary for fixing the shift_right bug, but logically unrelated to the shift_right code - it brings a chain of downstream interface modifications (7 files), unrelated to shift_right
44 lines
1.4 KiB
C++
44 lines
1.4 KiB
C++
/*
|
|
* Copyright (c) 2020, Itamar S. <itamar8910@gmail.com>
|
|
* Copyright (c) 2020-2021, Dex♪ <dexes.ttp@gmail.com>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include "UnsignedBigIntegerAlgorithms.h"
|
|
|
|
namespace Crypto {
|
|
|
|
/**
|
|
* Complexity: O(N^2) where N is the number of words in the larger number
|
|
* Multiplication method:
|
|
* An integer is equal to the sum of the powers of two
|
|
* according to the indices of its 'on' bits.
|
|
* So to multiple x*y, we go over each '1' bit in x (say the i'th bit),
|
|
* and add y<<i to the result.
|
|
*/
|
|
FLATTEN void UnsignedBigIntegerAlgorithms::multiply_without_allocation(
|
|
UnsignedBigInteger const& left,
|
|
UnsignedBigInteger const& right,
|
|
UnsignedBigInteger& temp_shift,
|
|
UnsignedBigInteger& output)
|
|
{
|
|
output.set_to_0();
|
|
|
|
// iterate all bits
|
|
for (size_t word_index = 0; word_index < left.length(); ++word_index) {
|
|
for (size_t bit_index = 0; bit_index < UnsignedBigInteger::BITS_IN_WORD; ++bit_index) {
|
|
// If the bit is off - skip over it
|
|
if (!(left.m_words[word_index] & (1 << bit_index)))
|
|
continue;
|
|
|
|
size_t shift_amount = word_index * UnsignedBigInteger::BITS_IN_WORD + bit_index;
|
|
|
|
// output += (right << shift_amount);
|
|
shift_left_without_allocation(right, shift_amount, temp_shift);
|
|
add_into_accumulator_without_allocation(output, temp_shift);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|