Python 与 Julia 速度比较

Question

我试着比较这两个片段，看看一秒钟可以完成多少次迭代。事实证明，Julia 实现了 250 万次迭代，而 Python 实现了 400 万次。 Julia 不是应该更快吗？或者这两个片段可能不等价？

python :

t1 = time.time()
i = 0
while True:
    i += 1
    if time.time() - t1 >= 1:
        break

Julia :

function f()
    i = 0
    t1 = now()
    while true
        i += 1
        if now() - t1 >= Base.Dates.Millisecond(1000)
            break
        end
    end
    return i
end

Answer 1

这是一种奇怪的性能比较，因为通常会测量计算实质内容所需的时间，而不是查看在一定时间内可以进行多少次琐碎的迭代。我无法让您的 Python 和 Julia 代码正常工作，因此我修改了 Julia 代码以使其正常工作，只是没有运行 Python 代码。正如@chepner 在评论中指出的，使用 now()并与 DateTime 进行时间比较对象相当昂贵。 Python time.time()函数只返回一个浮点值。事实证明，有一个名为 time() 的 Julia 函数。做同样的事情:

julia> time()
1.587648091474481e9

这是你原来的时间 f()我的系统上的功能(修改为工作):

julia> using Dates

julia> function f()
           i = 0
           t1 = now()
           while true
               i += 1
               if now() - t1 >= Millisecond(1000)
                   break
               end
           end
           return i
       end
f (generic function with 1 method)

julia> f()
4943739

它在时间结束之前进行了近 500 万次迭代。正如我所说，我无法让您的 Python 代码在我的系统上运行而无需大量摆弄(我没有费心去做)。但这里有一个版本的 f()使用 time()相反，我会富有想象力地称之为 g() :

julia> function g()
           i = 0
           t1 = time()
           while true
               i += 1
               if time() - t1 >= 1
                   break
               end
           end
           return i
       end
g (generic function with 1 method)

julia> g()
36087637

这个版本进行了 3600 万次迭代。所以我猜 Julia 的循环速度更快？耶!嗯，实际上这个循环中的主要工作是调用 time()所以... Julia 生成大量 time() 的速度更快来电!

为什么这个时间很奇怪？正如我所说，这里的大部分实际工作都是调用 time() .循环的其余部分并没有真正做任何事情。在优化编译语言中，如果编译器看到一个没有做任何事情的循环，它将完全消除它。例如:

julia> function h()
           t = 0
           for i = 1:100_000_000
               t += i
           end
           return t
       end
h (generic function with 1 method)

julia> h()
5000000050000000

julia> @time h()
  0.000000 seconds
5000000050000000    

哇，零秒!这怎么可能？好吧，让我们看看 LLVM code (有点像机器代码，但对于用作中间表示的虚构机器)这降低为:

julia> @code_llvm h()

;  @ REPL[16]:1 within `h'
define i64 @julia_h_293() {
top:
;  @ REPL[16]:6 within `h'
  ret i64 5000000050000000
}

编译器看到循环，计算出每次的结果都相同，并且只返回该常量值而不是实际执行循环。当然，这需要零时间。