Увеличение производительности Java BigInteger

Как увеличить производительность Java Big Integer?

Например, эта факториальная программа:

import java.math.*;
class Fac {
  public static void main(String[] args) {
    BigInteger i = BigInteger.ONE;
    for(BigInteger z=BigInteger.valueOf(2);z.compareTo(BigInteger.valueOf(99999)) != 0;) {
      i = i.multiply(z);
      z = z.add(BigInteger.ONE);
    }
    System.out.println( i );
  }
}

Эта программа завершена в 31.5 s

Где в С++:

#include <iostream>
#include <gmpxx.h>
using namespace std;
int main() {
  mpz_class r;
  r = 1;
  for(int z=2;z<99999;++z) {
    r *= mpz_class(z);
  }
  cout << r << endl;
}

завершено в 1.0 s

И Ruby (для сравнения):

puts (2...99999).inject(:*)

завершено в 4.4 (Ruby) и 32.2 в JRuby

И также Go (для сравнения):

package main
import (
 "fmt"
 "math/big"
)
func main() {
  i := big.NewInt(1);
  one := big.NewInt(1)
  for z := big.NewInt(2); z.Cmp(big.NewInt(99999)) < 0;  {
      i.Mul(i,z);
      z.Add(z,one)
  }
  fmt.Println( i );
}

завершено в 1.6 и 0.7 для MulRange

РЕДАКТИРОВАТЬ В соответствии с запросом:

import java.math.*;
class F2 {
  public static void main(String[] args) {
    BigInteger i = BigInteger.ONE, r = BigInteger.valueOf(2);
    for(int z=2; z<99999 ; ++z) {
      i = i.multiply(r);
      r = r.add(BigInteger.ONE);
    }
    System.out.println( i );
  }
}

продолжительность выполнения: 31.4 s

РЕДАКТИРОВАТЬ 2 для тех, кто все еще считает, что первый и второй Java-код несправедливы.

import java.math.*;
class F3 {
  public static void main(String[] args) {
    BigInteger i = BigInteger.ONE;
    for(int z=2; z<99999 ; ++z) {
      i = i.multiply(BigInteger.valueOf(z));
    }
    System.out.println( i );
  }
}

завершено в 31.1 s

РЕДАКТИРОВАТЬ 3 комментарий @OldCurmudgeon:

import java.math.*;
import java.lang.reflect.*;
class F4 {
  public static void main(String[] args) {
    try {
      Constructor<?> Bignum = Class.forName("java.math.MutableBigInteger").getDeclaredConstructor(int.class);
      Bignum.setAccessible(true);
      Object i = Bignum.newInstance(1);
      Method m = i.getClass().getDeclaredMethod("mul", new Class[] { int.class, i.getClass()});
      m.setAccessible(true);
      for(int z=2; z<99999 ; ++z) {
        m.invoke(i, z, i);
      }
      System.out.println( i );
    } catch(Exception e) { System.err.println(e); } 
  }
}

завершено в 23.7 s

РЕДАКТИРОВАТЬ 4 Как заявила @Marco13, самая большая проблема заключалась в создании строки не на самом BigInteger.

  • BigInteger: 3.0 s
  • MutableBigInteger hack: 10.1 s
  • Создание строки: ~ 20 s

ОТВЕТЫ

Ответ 1

Само вычисление не должно длиться так долго. Однако создание строки может занять некоторое время.

Эта программа (Kudos to OldCurmudgeon и fooobar.com/questions/399639/...) занимает примерно 3,9 секунды на Core I7, 3GHz, Java 7/21, при запуске с -Xmx1000m -sever:

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class FastBigInteger
{
    public static void main(String[] args)
    {
        try
        {
            Class<?> c = Class.forName("java.math.MutableBigInteger");
            Constructor<?> con = c.getDeclaredConstructor(int.class);
            con.setAccessible(true);
            Object i = con.newInstance(1);
            Method m = c.getDeclaredMethod("mul", new Class[] { int.class, c });
            m.setAccessible(true);
            long before = System.nanoTime();
            for (int z = 2; z < 99999; ++z)
            {
                m.invoke(i, z, i);
            }
            long after = System.nanoTime();
            System.out.println("Duration "+(after-before)/1e9);

            String s = i.toString();
            int n = s.length();
            int lineWidth = 200;
            for (int j=0; j<n; j+=lineWidth)
            {
                int j0 = j;
                int j1 = Math.min(s.length(), j+lineWidth);
                System.out.println(s.substring(j0, j1));
            }
        }
        catch (Exception e)
        {
            System.err.println(e);
        }
    }
}

После печати продолжительности фактического вычисления требуется довольно долгое время, пока он не завершит создание строки, но здесь это вряд ли следует принимать во внимание.

Это по-прежнему не разумный тест, но показывает, что, по крайней мере, проблема с самим вычислением.

Но, по общему признанию, при использовании только BigInteger вместо этого MutableBigInteger hack требуется appx. 15 секунд, что довольно плохо по сравнению с реализацией на С++.

Ответ 2

Начните с:

import java.math.*;
class Fac {
  public static void main(String[] args) {
    BigInteger i = BigInteger.ONE;
    BigInteger maxValue = BigInteger.valueOf(99999);

    for(BigInteger z=BigInteger.valueOf(2); z.compareTo(maxValue) != 0;) {
      i = i.multiply(z);
      z = z.add(BigInteger.ONE);
    }

    System.out.println( i );
  }
}

.valueOf source

1081    public static BigInteger More ...valueOf(long val) {
1082        // If -MAX_CONSTANT < val < MAX_CONSTANT, return stashed constant
1083        if (val == 0)
1084            return ZERO;
1085        if (val > 0 && val <= MAX_CONSTANT)
1086            return posConst[(int) val];
1087        else if (val < 0 && val >= -MAX_CONSTANT)
1088            return negConst[(int) -val];
1089
1090        return new BigInteger(val);
1091    }

Он будет создавать новый BigInteger каждый раз, так как MAX_CONSTANT равно 16.

Я думаю, что это может пойти медленнее, потому что GC начинает собирать несколько старых экземпляров BigInteger, но в любом случае вы всегда должны использовать int и long.. здесь BigInteger действительно не нужен.

После вашего последнего теста я думаю, что мы можем быть уверены, что это может быть вызвано GC.

Ответ 3

У меня есть код clojure, вычисляющий 100 000-й номер фибоначчи с использованием больших целых чисел. Теперь этот поток не о clojure, но поскольку clojure работает на JVM, и я запускал тесты на некоторые из существующих реализаций большого целого числа, я чувствовал, что комментарий здесь может быть ценным.

Алгоритм, когда он использует класс JVM BigInteger (обозначается синтаксисом xN литерала в clojure), выглядит следующим образом:

(defn fibo [n]
  (loop [i n a 1N b 1N]
    (if (> i 0)
      (recur (dec i) b (+ a b))
      a)))

Я повторно выполнил это с использованием четырех больших целых реализаций, и я провел тесты, используя библиотеку clojure criterium, которая делает тепло и некоторый статистический анализ, чтобы попытаться получить несколько соответствующих номеров.

Результаты моего 2,8 ГГц Intel Core i7 macbook:

Теперь я понимаю, что это все анекдотично и что мы только измеряем добавление здесь, но я должен был бы сказать, что фраза huldra catch "Превосходительство BigInteger с 2015 года" кажется довольно точной в этом случае.

Любые комментарии с указателями на потенциальных кандидатов для более быстрых алгоритмов добавления больших чисел очень ценятся.

Ответ 4

Другие ответы связаны с настройкой производительности с помощью кода.

Если вы используете версию java меньше 1,8.051, вы можете настроить большую целую производительность, используя следующие параметры команды:

-XX:-UseMontgomerySquareIntrinsic
-XX:-UseMontgomeryMultiplyIntrinsic
-XX:-UseSquareToLenIntrinsic
-XX:-UseMultiplyToLenIntrinsic

После 1.8.051 эти параметры включены по умолчанию.