Merge #25

25: do not convert carry/borrow to/from DoubleBigDigit r=cuviper a=tspiteri

Currently `adc`, `sbb`, `mac_with_carry` and `mul_with_carry` in *algorithms.rs* take the carry/borrow as a `BigDigit`, then convert it every iteration to `DoubleBigDigit` for the addition/subtraction. With this commit, a kind of accumulator takes place of the carry and borrow. It is stored as a `DoubleBigDigit` and not converted to/from `BigDigit` at all. For subtraction, the accumulator is stored as a `SignedDoubleBigDigit` in order to enable arithmetic right shift and to be able to easily handle subtraction.

I'm not very familiar with the crate's benchmarking methods. I wrote some hacky benchmarks for a quick comparison. Basically, just have two vectors `[10000000, 0, !0, 1, 29999999]` and `[10, !0, 5, 234, 23]`, and add/subtract/multiply a couple hundred times. I saw these gains:
```
running 6 tests
test tests::bench_changed_add  ... bench:         992 ns/iter (+/- 58)
test tests::bench_changed_mul  ... bench:       9,667 ns/iter (+/- 185)
test tests::bench_changed_sub  ... bench:       1,497 ns/iter (+/- 38)
test tests::bench_original_add ... bench:       1,085 ns/iter (+/- 50)
test tests::bench_original_mul ... bench:       9,838 ns/iter (+/- 284)
test tests::bench_original_sub ... bench:       1,642 ns/iter (+/- 14)
```

The gains are not very large, after all only a couple of assembly instructions per iteration are saved. I also do not know whether other architectures than x86_64 are affected similarly or in the opposite direction.

The change in the parameter from `&mut BigDigit` to `&mut DoubleBigDigit` is automatically handled in other files, as carry is simply initialized as zero and compared to zero at the end, with the type being inferred.

Author: bors[bot]

src/algorithms.rs

@@ -21,6 +21,9 @@ pub mod big_digit {
     /// size is the double of the size of `BigDigit`.
     pub type DoubleBigDigit = u64;
 
+    /// A `SignedDoubleBigDigit` is the signed version of `DoubleBigDigit`.
+    pub type SignedDoubleBigDigit = i64;
+
     pub const ZERO_BIG_DIGIT: BigDigit = 0;
 
     // `DoubleBigDigit` size dependent
@@ -51,47 +54,44 @@ pub mod big_digit {
     }
 }
 
-use big_digit::{BigDigit, DoubleBigDigit};
+use big_digit::{BigDigit, DoubleBigDigit, SignedDoubleBigDigit};
 
 // Generic functions for add/subtract/multiply with carry/borrow:
 
 // Add with carry:
 #[inline]
-fn adc(a: BigDigit, b: BigDigit, carry: &mut BigDigit) -> BigDigit {
-    let (hi, lo) = big_digit::from_doublebigdigit((a as DoubleBigDigit) + (b as DoubleBigDigit) +
-                                                  (*carry as DoubleBigDigit));
-
-    *carry = hi;
+fn adc(a: BigDigit, b: BigDigit, acc: &mut DoubleBigDigit) -> BigDigit {
+    *acc += a as DoubleBigDigit;
+    *acc += b as DoubleBigDigit;
+    let lo = *acc as BigDigit;
+    *acc >>= big_digit::BITS;
     lo
 }
 
 // Subtract with borrow:
 #[inline]
-fn sbb(a: BigDigit, b: BigDigit, borrow: &mut BigDigit) -> BigDigit {
-    let (hi, lo) = big_digit::from_doublebigdigit(big_digit::BASE + (a as DoubleBigDigit) -
-                                                  (b as DoubleBigDigit) -
-                                                  (*borrow as DoubleBigDigit));
-    // hi * (base) + lo == 1*(base) + ai - bi - borrow
-    // => ai - bi - borrow < 0 <=> hi == 0
-    *borrow = (hi == 0) as BigDigit;
+fn sbb(a: BigDigit, b: BigDigit, acc: &mut SignedDoubleBigDigit) -> BigDigit {
+    *acc += a as SignedDoubleBigDigit;
+    *acc -= b as SignedDoubleBigDigit;
+    let lo = *acc as BigDigit;
+    *acc >>= big_digit::BITS;
     lo
 }
 
 #[inline]
-pub fn mac_with_carry(a: BigDigit, b: BigDigit, c: BigDigit, carry: &mut BigDigit) -> BigDigit {
-    let (hi, lo) = big_digit::from_doublebigdigit((a as DoubleBigDigit) +
-                                                  (b as DoubleBigDigit) * (c as DoubleBigDigit) +
-                                                  (*carry as DoubleBigDigit));
-    *carry = hi;
+pub fn mac_with_carry(a: BigDigit, b: BigDigit, c: BigDigit, acc: &mut DoubleBigDigit) -> BigDigit {
+    *acc += a as DoubleBigDigit;
+    *acc += (b as DoubleBigDigit) * (c as DoubleBigDigit);
+    let lo = *acc as BigDigit;
+    *acc >>= big_digit::BITS;
     lo
 }
 
 #[inline]
-pub fn mul_with_carry(a: BigDigit, b: BigDigit, carry: &mut BigDigit) -> BigDigit {
-    let (hi, lo) = big_digit::from_doublebigdigit((a as DoubleBigDigit) * (b as DoubleBigDigit) +
-                                                  (*carry as DoubleBigDigit));
-
-    *carry = hi;
+pub fn mul_with_carry(a: BigDigit, b: BigDigit, acc: &mut DoubleBigDigit) -> BigDigit {
+    *acc += (a as DoubleBigDigit) * (b as DoubleBigDigit);
+    let lo = *acc as BigDigit;
+    *acc >>= big_digit::BITS;
     lo
 }
 
@@ -141,7 +141,7 @@ pub fn __add2(a: &mut [BigDigit], b: &[BigDigit]) -> BigDigit {
         }
     }
 
-    carry
+    carry as BigDigit
 }
 
 /// /Two argument addition of raw slices:
@@ -446,7 +446,7 @@ pub fn scalar_mul(a: &mut [BigDigit], b: BigDigit) -> BigDigit {
     for a in a.iter_mut() {
         *a = mul_with_carry(*a, b, &mut carry);
     }
-    carry
+    carry as BigDigit
 }
 
 pub fn div_rem(u: &BigUint, d: &BigUint) -> (BigUint, BigUint) {