BigInts 在 Julia 中似乎很慢

Question

I'm really impressed with Julia since it ran faster than D on a processor intensive Euler Project question. #303 if anyone is interested.

What's weird is how slow BigInts in Julia seems to be. Strange because I read their performance is quite good.

The following is a Julia program to calculate the number of partitions of 15k using Euler's recurrence formula.

function eu78()
  lim = 15000
  ps = zeros(BigInt, lim)

  function p(n)  #applies Euler recurrence formula
    if n < 0
      return BigInt(0)
    elseif n == 0
      return BigInt(1)
    elseif ps[n] > 0
      return ps[n]
    end
    s = BigInt(0)
    f = BigInt(-1)
    for k = 1 : n
      f *= -1
      t1 = (k * (3k - 1)) ÷ BigInt(2)
      t2 = (k * (3k + 1)) ÷ 2
      s += f * (p(n - t1) + p(n - t2))
    end
    ps[n] = s
  end

  for i = 1 : lim
    p(i)
  end
  println(ps[lim])
end

eu78()

Runs in a whopping 3min43sec to generate the 132 digit answer.

The equivalent Python code run with pypy takes a mere 8 seconds.

What am I doing wrong?

Answer 1

BigInts are currently pretty slow in Julia. This is because each operation allocates a new BigInt, as opposed to Python where all integers are BigInts and therefore they've spent a fair amount of time making sure that basic operations are fast. Python actually uses a hybrid approach where small integer values are represented inline and only when values get too large are they represented as BigInts. The same could absolutely be done in Julia, but no one has implemented this yet – partly because standard Int values are machine integers and therefore the performance of BigInts is not critical. The real boost to BigInt performance will come from integrating Julia's BigInt type with GC and allowing small BigInt values to be stack allocated – and to live in registers. We're not quite there yet, however.

Answer 2

The following version runs in under 12 seconds on my machine with Julia 0.4:

const lim = 6*10^4
const ps = zeros(Int64, lim)
ps[1] = 1

function p(n)  #applies Euler recurrence formula for the number of partitions
    n < 0 && return 0
    n == 0 && return 1

    ps[n] > 0 && return ps[n]

    s, f = 0, -1

    for k = 1:n
      f *= -1
      t1 = (k * (3k - 1)) ÷ 2
      t2 = (k * (3k + 1)) ÷ 2
      s += f * (p(n - t1) + p(n - t2))
    end

    siz = 10^9
    ps[n] = mod(s, siz)
end

function eu78(lim=6*10^4)

    for i = 10:lim
        a = p(i)
        if mod(a, 1000000) == 0
            return (i, a)
        end
    end
end

@time eu78(10)  # warm-up

@time eu78(6*10^4)

Answer 3

The question is 5 years old but I'm answering for future reference.

Unfortunately BigInts are quite slow in Julia by default. Maybe they will get faster in the future with better compiler tech, but for now one needs to manually tweak the code to achieve better performance.

There are two things in your code that are slowing it down.

1. First, as any guide on Julia optimization would suggest, one need to reduce memory allocation . And construct a BigInt allocates memory, so one should avoid declare BigInt if possible. Hence in

   if n < 0 return BigInt(0)

   the BigInt(0) should be replaced with big"0" , or alternatively, with a predefined constant ZERO = BigInt(0) , to avoid creating a zero every time.

   Another important issue is the use of inplace operators for BigInt arithmetic . When we write a += b , Julia creates a new BigInt c with value a + b , and links a to it. To avoid the allocation, we should use the inplace operator Base.GMP.MPZ.add!(a, b) instead, which directly adds the value of b to a .

   So instead of s += f * (p(n - t1) + p(n - t2)) one should write

   add!(s, p(n - t1)) add!(s, p(n - t2))

   (or sub! if f is negative). Note that the two terms should be separated, since p(n - t1) + p(n - t2) will still allocate a BigInt.

   With these two improvement, the code for lim = 15000 can finish in 6s, opposed to the original at around 160s (notice the significant drop of memory allocations).

    6.020336 seconds (224.91 M allocations: 3.353 GiB, 1.34% gc time, 0.40% compilation time)

    162.123506 seconds (2.47 G allocations: 49.384 GiB, 28.53% gc time, 0.06% compilation time)

2. As mentioned in the other answer, we should avoid nested functions if possible. I don't have a precise explanation (probably because Julia needs to create the scope for such function), but if you move the function p outside of eu78 and pass the vector ps to it as an argument, the code will finish in just 2s. This is as fast as C with the GMP big number library (which is what Julia's BigInt uses under the hood) and is quite impressive. BTW with pypy3 and the same algorithm I get a runtime of 26s. So the claimed 8s in 2016 looks very suspicious to me...

    1.910670 seconds (45.22 k allocations: 1.259 MiB)

And here is the code after modification.

import Base.GMP.MPZ: add!, sub!
function p(n, ps)  #applies Euler recurrence formula
  if n < 0
    return big"0"
  elseif n == 0
    return big"1"
  elseif ps[n] > 0
    return ps[n]
  end
  s = BigInt(0)
  for k = 1 : n
    t1 = (k * (3k - 1)) ÷ 2
    t2 = (k * (3k + 1)) ÷ 2
    if iseven(k)
      sub!(s, p(n - t1, ps))
      sub!(s, p(n - t2, ps))
    else
      add!(s, p(n - t1, ps))
      add!(s, p(n - t2, ps))
    end
  end
  ps[n] = s
end

function eu78()
  lim = 15000
  ps = zeros(BigInt, lim)
  for i = 1 : lim
    p(i, ps)
  end
  println(ps[lim])
end

@time eu78()

Answer 4

Thanks Stefan for that quick response.

I feel though that there is something else going on since a Julia version without bigints still runs orders of magnitude slower than pypy.

So this is not so much an answer as a different question.

That Euler Project question is to find the first number whose partitiions total a multiple of a million. So we need just over 6 significant digits so it can be done using machine integers.

Here is this version in Julia, which completes in 2min44sec.

function eu78()
  const lim = 6 * 10 ^ 4
  ps = zeros(Int64, lim)
  ps[1] = 1
  const siz = 10 ^ 9

  function p(n)  #applies Euler recurrence formula for the number of partitions
    if n < 0
      return 0
    elseif n == 0
      return 1
    elseif ps[n] > 0
      return ps[n]
    end
    s, f = 0, -1
    for k = 1 : n
      f *= -1
      t1 = (k * (3k - 1)) ÷ 2
      t2 = (k * (3k + 1)) ÷ 2
      s += f * (p(n - t1) + p(n - t2))
    end
    ps[n] = mod(s, siz)
  end

 for i = 10 : lim
   a = p(i)
   if mod(a, 1000000) == 0
     println(i,'\n', a)
     break
   end
 end
end

eu78()

(Incidentally, thanks guys for using % in Julia to give the remainder rather than the more usual modulus. :) That cost me a whole evening trying to get it to return an answer, anything %$#%&! rather than nothing at all.)

The python version running in pypy completes in 41 sec, a quarter of the time. (To be fair, running in python2, it takes 13min48 sec.)

So what's the problem? The double recursion in line 20? How can I get the speed up? Not that anyone reading this will care, but there is a one minute rule on program execution in Project Euler.