13

value = i % 65536いじくり回しているプログラムを最適化しようとしていたとき、実行が実行よりも遅いように見えることに気付きましたvalue = i % (2**16)。

これをテストするために、次のプログラムを実行しました。

import cProfile
import pstats

AMOUNT = 100000000

def test1():
    for i in xrange(AMOUNT):
        value = i % 65536
    return

def test2():
    for i in xrange(AMOUNT):
        value = i % (256**2)
    return

def test3():
    for i in xrange(AMOUNT):
        value = i % (16**4)
    return

def test4():
    for i in xrange(AMOUNT):
        value = i % (4**8)
    return

def test5():
    for i in xrange(AMOUNT):
        value = i % (2**16)
    return

def run_tests():
    test1()
    test2()
    test3()
    test4()
    test5()
    return

if __name__ == '__main__':
    cProfile.run('run_tests()', 'results')
    stats = pstats.Stats('results')
    stats.sort_stats('calls', 'nfl')
    stats.print_stats()

...次の出力が生成されました。

Fri May 11 15:11:59 2012    results

         8 function calls in 40.473 seconds

   Ordered by: call count, name/file/line

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
        1    0.000    0.000   40.473   40.473 <string>:1(<module>)
        1    0.000    0.000   40.473   40.473 test.py:31(run_tests)
        1   10.466   10.466   10.466   10.466 test.py:6(test1)
        1    7.475    7.475    7.475    7.475 test.py:11(test2)
        1    7.485    7.485    7.485    7.485 test.py:16(test3)
        1    7.539    7.539    7.539    7.539 test.py:21(test4)
        1    7.508    7.508    7.508    7.508 test.py:26(test5)

using65536は 10.466 秒で最も遅く、doing は 7.475 秒で256**2最も高速でした (他の可能な指数値はその間にあります)。確かに、この速度の違いは、繰り返し回数が多い場合にのみ顕著になりますが、なぜこれが発生するのかについてはまだ興味があります.

65536指数を使用して mod を取得するよりも、数値の mod を取得する方が遅いのはなぜですか? それらは同じ数値に評価されるはずであり、mod を使用する前に Python インタープリターが指数を完全に評価するには時間がかかると思っていたでしょう。

拡張により、数値を完全に入力するよりも、python 式で 2 の累乗を使用する方が一般的に効率的ですか? また、このパターンは、モジュラス以外の演算や 以外の数値にも当てはまります2か?

（ところで、私はPython 2.7.2（32ビット）を使用しており、64ビットのWindows 7ラップトップで上記を実行しました）。

編集:
だから私は呼び出す関数の順序を逆にしてみましたが、今は逆です。run_testscProfile を使用すると、最初の関数の実行速度が常に少し遅くなるように見えますが、これは奇妙なことです。だから、学んだ教訓は、私が推測する - プロファイラーは奇妙です:D

4

3 に答える 3

19

生成されたバイトコードに違いはありません。これは、コンパイラが適切に機能し、定数算術式を最適化するためです。これは、テスト結果が単なる偶然であることを意味します (関数のタイミングを別の順序で試してみてください!)。

>>> import dis
>>> dis.dis(test1)
  2           0 SETUP_LOOP              30 (to 33)
              3 LOAD_GLOBAL              0 (xrange)
              6 LOAD_GLOBAL              1 (AMOUNT)
              9 CALL_FUNCTION            1
             12 GET_ITER            
        >>   13 FOR_ITER                16 (to 32)
             16 STORE_FAST               0 (i)

  3          19 LOAD_FAST                0 (i)
             22 LOAD_CONST               1 (65536)
             25 BINARY_MODULO       
             26 STORE_FAST               1 (value)
             29 JUMP_ABSOLUTE           13
        >>   32 POP_BLOCK           

  4     >>   33 LOAD_CONST               0 (None)
             36 RETURN_VALUE        
>>> dis.dis(test5)
  2           0 SETUP_LOOP              30 (to 33)
              3 LOAD_GLOBAL              0 (xrange)
              6 LOAD_GLOBAL              1 (AMOUNT)
              9 CALL_FUNCTION            1
             12 GET_ITER            
        >>   13 FOR_ITER                16 (to 32)
             16 STORE_FAST               0 (i)

  3          19 LOAD_FAST                0 (i)
             22 LOAD_CONST               3 (65536)
             25 BINARY_MODULO       
             26 STORE_FAST               1 (value)
             29 JUMP_ABSOLUTE           13
        >>   32 POP_BLOCK           

  4     >>   33 LOAD_CONST               0 (None)
             36 RETURN_VALUE

（実際には違いがあります。数値は定数テーブルの異なるオフセットに格納されます。ただし、これが違いを引き起こすとは想像できません）。

timeit完全を期すために、モジュールを使用する適切なテストを次に示します。

import timeit

setup = "i = 1337"

best1 = best2 = float("inf")
for _ in range(5000):
  best1 = min(best1, timeit.timeit("i % 65536", setup=setup, number=10000))
for _ in range(5000):
  best2 = min(best2, timeit.timeit("i % (2**16)", setup=setup, number=10000))
print best1
print best2

平均ではなく、必要な最小時間を測定していることに注意してください。何らかの理由で時間がかかる場合は、より頻繁に中断されたことを意味します (コードは CPU の能力以外には依存しないため)。

于 2012-05-11T22:32:43.250 に答える
6

うーん、disを使用してPythonバイトコードを表示すると、関数が同一であることを示します。Pythonは定数を最適化しました（予想どおり）。したがって、時差がキャッシュ効果であると思われます。私のラップトップのタイミングはこれを裏付けています（LinuxでPython 2.7.3 64ビットを使用）

Fri May 11 23:37:49 2012    results

     8 function calls in 38.825 seconds

Ordered by: call count, name/file/line

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
     1    0.000    0.000   38.825   38.825 <string>:1(<module>)
     1    0.000    0.000   38.825   38.825 z.py:31(run_tests)
     1    7.880    7.880    7.880    7.880 z.py:6(test1)
     1    7.658    7.658    7.658    7.658 z.py:11(test2)
     1    7.806    7.806    7.806    7.806 z.py:16(test3)
     1    7.784    7.784    7.784    7.784 z.py:21(test4)
     1    7.697    7.697    7.697    7.697 z.py:26(test5)

すべてほぼ同じ

>>> from dis import dis
>>> def test1():
...     for i in xrange(AMOUNT):
...         value = i % 65536
...     return
... 
>>> def test5():
...     for i in xrange(AMOUNT):
...         value = i % (2**16)
...     return
... 
>>> dis(test1)
  2           0 SETUP_LOOP              30 (to 33)
              3 LOAD_GLOBAL              0 (xrange)
              6 LOAD_GLOBAL              1 (AMOUNT)
              9 CALL_FUNCTION            1
             12 GET_ITER            
        >>   13 FOR_ITER                16 (to 32)
             16 STORE_FAST               0 (i)

  3          19 LOAD_FAST                0 (i)
             22 LOAD_CONST               1 (65536)
             25 BINARY_MODULO       
             26 STORE_FAST               1 (value)
             29 JUMP_ABSOLUTE           13
        >>   32 POP_BLOCK           

  4     >>   33 LOAD_CONST               0 (None)
             36 RETURN_VALUE        
>>> dis(test5)
  2           0 SETUP_LOOP              30 (to 33)
              3 LOAD_GLOBAL              0 (xrange)
              6 LOAD_GLOBAL              1 (AMOUNT)
              9 CALL_FUNCTION            1
             12 GET_ITER            
        >>   13 FOR_ITER                16 (to 32)
             16 STORE_FAST               0 (i)

  3          19 LOAD_FAST                0 (i)
             22 LOAD_CONST               3 (65536)
             25 BINARY_MODULO       
             26 STORE_FAST               1 (value)
             29 JUMP_ABSOLUTE           13
        >>   32 POP_BLOCK           

  4     >>   33 LOAD_CONST               0 (None)
             36 RETURN_VALUE        
>>>
于 2012-05-11T22:39:27.717 に答える
4

すべてのテストを1回だけ実行しました。CPUの速度は常に同じではありません。テストの開始時には、おそらくスリープ状態でした。そのため、最初のテストは遅くなりました。コードの小さな部分（modなど）のベンチマークには、timeitモジュールを使用します。

>>> timeit.timeit('for i in range(10000): i % 65536', number=1000)
0.8686108589172363
>>> timeit.timeit('for i in range(10000): i % 256**2', number=1000)
0.862062931060791
>>> timeit.timeit('for i in range(10000): i % 4**8', number=1000)
0.8644928932189941
>>> timeit.timeit('for i in range(10000): i % 2**16', number=1000)
0.8643178939819336
>>> timeit.timeit('for i in range(10000): i % 65536', number=1000)
0.8640358448028564

平均は常に約0.864であることがわかります。

于 2012-05-11T22:40:32.333 に答える