Python 3 type hints for performance optimizations

Question

PEP 484 says "Using type hints for performance optimizations is left as an exercise for the reader." This suggests to me that, like Common Lisp, type declarations can be used to set aside type dispatch inside performance-intensive functions when I swear I know what I'm doing. To try this out for myself, I whipped up a little benchmark to calculate pi using a p-series. First I do it the naive way, then I try to be clever and exploit the type hints for performance:

import math
import time

def baselpi0(n):
    baselsum = 0;
    for i in range(1,n):
        baselsum += 1.0 / (i * i)
    return math.sqrt(6.0 * baselsum)

def baselpi1(n : int) -> float:
    n = float(n)
    baselsum  = 0.0
    i = 1.0
    while i < n:
        baselsum += 1.0 / (i * i)
        i += 1.0
    return math.sqrt(6.0 * baselsum)

start = time.time()
print(baselpi0(1000000000))
end = time.time()
print(end - start)
start = time.time()
print(baselpi1(1000000000))
end = time.time()
print(end - start)

The Common Lisp analogy I'm trying to emulate is:

(defun baselpi0 (n)
  (let ((baselsum 0.0d0))
    (loop for i from 1 to n do
      (setf baselsum (+ baselsum (/ 1.0 (* i i)))))
    (sqrt (* 6 baselsum))))

(defun baselpi1 (n)
  (let ((baselsum 0.0d0)
        (n (coerce n 'double-float)))
    (declare (type double-float baselsum n)
         (optimize (speed 3) (safety 0) (debug 0)))
    (loop for i from 1.0d0 to n do
          (setf baselsum (+ baselsum (/ 1.0d0 (* i i)))))
    (sqrt (* 6.0d0 baselsum))))

(time (princ (baselpi0 1000000000)))
(time (princ (baselpi1 1000000000)))
(exit)

On my machine, the lisp version run with sbcl takes 22 seconds for the slow version and 4 seconds for the type-hinted version, same as C. CPython takes 162 seconds for the naive version and 141 for the type-hinted version. Pypy runs the non-type-hinted version in just under 5 seconds, but the library support isn't good enough for my project.

Is there a way I can improve my type hinted version to get performance closer to lisp or Pypy?

Answer 1

The speed difference is not due to type-hinting. Python currently, and for the foreseeable future, just discards any hints you offer and continues executing dynamically as it always does.

It's due to the fact that in one case you use floating arithmetic throughout the code (which results in faster execution) while in the other case you don't.

Case in point: Change baselpi1 to the following:

def baselpi1(n : int) -> float:
    n = float(n)
    baselsum  = 0
    i = 1
    while i < n:
        baselsum += 1.0 / (i * i)
        i += 1
    return math.sqrt(6.0 * baselsum)

And take a look at the execution times now:

3.141591698659554
0.2511475086212158
3.141591698659554
0.4525010585784912

Yes, it is way slower.