web-dev-qa-db-ja.com

シャッフルされたリストのコピーがずっと遅いのはなぜですか？

シャッフルされたrange(10**6)リストを10回コピーすると、約0.18秒かかります（これらは5回実行されます）

_0.175597017661
0.173731403198
0.178601711594
0.180330912952
0.180811964451
_

シャッフルされていないリストを10回コピーすると、約0.05秒かかります。

_0.058402235973
0.0505464636856
0.0509734306934
0.0526022752744
0.0513324916184
_

これが私のテストコードです。

_from timeit import timeit
import random

a = range(10**6)
random.shuffle(a)    # Remove this for the second test.
a = list(a)          # Just an attempt to "normalize" the list.
for _ in range(5):
    print timeit(lambda: list(a), number=10)
_

また、_a[:]_を使用してコピーしようとしましたが、結果は同様でした（つまり、大きな速度差）

なぜ大きな速度差があるのですか？私は有名な ソートされていない配列よりもソートされた配列を処理するほうが速いのはなぜですか の例の速度の違いを知っていますが、ここでは処理に決定がありません。リスト内の参照を盲目的にコピーしているだけですよね？

Windows 10ではPython 2.7.12を使用しています。

編集：Python 3.5.2も試してみましたが、結果はほぼ同じでした（0.17秒前後に一貫してシャッフルされました） 、常に0.05秒前後にシャッフルされていない）。そのためのコードは次のとおりです。

_a = list(range(10**6))
random.shuffle(a)
a = list(a)
for _ in range(5):
    print(timeit(lambda: list(a), number=10))
_
pythonpython-internals
87
Stefan Pochmann

興味深いのは、整数がfirstが作成される順序に依存することです。たとえば、shuffleの代わりに_random.randint_を使用してランダムシーケンスを作成します。

_from timeit import timeit
import random

a = [random.randint(0, 10**6) for _ in range(10**6)]
for _ in range(5):
    print(timeit(lambda: list(a), number=10))
_

これは、list(range(10**6))をコピーするのと同じくらい高速です（最初の高速な例）。

ただし、シャッフルすると、整数は最初に作成された順序ではなくなり、遅くなります。

簡単なインターメッツォ：

  • すべてのPythonオブジェクトはヒープ上にあるため、すべてのオブジェクトはポインターです。
  • リストのコピーは浅い操作です。
  • ただし、Pythonは参照カウントを使用するため、オブジェクトを新しいコンテナに入れる場合は、参照カウントを増やす必要があります（ _Py_INCREF_ in _list_slice_ ） 、そのためPythonは実際にオブジェクトのある場所に移動する必要があります。参照をコピーすることはできません。

したがって、リストをコピーすると、そのリストの各アイテムが取得され、新しいリストに「そのまま」配置されます。次のアイテムが現在のアイテムの直後に作成された場合、ヒープの隣に保存される可能性が十分にあります（保証なし！）。

コンピューターがキャッシュ内のアイテムを読み込むときはいつでも、xメモリ内の次のアイテム（キャッシュの場所）も読み込むと仮定しましょう。その後、コンピューターは同じキャッシュ上の_x+1_アイテムの参照カウントのインクリメントを実行できます！

シャッフルシーケンスでは、メモリ内の次のアイテムをロードしますが、これらはリスト内の次のアイテムではありません。そのため、次のアイテムを「本当に」探すことなく参照カウントのインクリメントを実行することはできません。

TL; DR：実際の速度は、コピー前に何が起こったかによって異なります。これらのアイテムが作成された順序とリスト内の順序は次のとおりです。

これを確認するには、 id を見てください。

CPython実装の詳細：これは、メモリ内のオブジェクトのアドレスです。

_a = list(range(10**6, 10**6+100))
for item in a:
    print(id(item))
_

短い抜粋を表示するだけです：

_1496489995888
1496489995920  # +32
1496489995952  # +32
1496489995984  # +32
1496489996016  # +32
1496489996048  # +32
1496489996080  # +32
1496489996112
1496489996144
1496489996176
1496489996208
1496489996240
1496507297840
1496507297872
1496507297904
1496507297936
1496507297968
1496507298000
1496507298032
1496507298064
1496507298096
1496507298128
1496507298160
1496507298192
_

したがって、これらのオブジェクトは実際には「ヒープ上で互いに隣接」しています。 shuffleを使用すると、次のことはできません。

_import random
a = list(range(10**6, 100+10**6))
random.shuffle(a)
last = None
for item in a:
    if last is not None:
        print('diff', id(item) - id(last))
    last = item
_

これは、これらが実際にメモリ内で隣り合っていないことを示しています。

_diff 736
diff -64
diff -17291008
diff -128
diff 288
diff -224
diff 17292032
diff -1312
diff 1088
diff -17292384
diff 17291072
diff 608
diff -17290848
diff 17289856
diff 928
diff -672
diff 864
diff -17290816
diff -128
diff -96
diff 17291552
diff -192
diff 96
diff -17291904
diff 17291680
diff -1152
diff 896
diff -17290528
diff 17290816
diff -992
diff 448
_

重要な注意：

私は自分でこれを考えていません。ほとんどの情報は Ricky Stewartのブログ投稿 にあります。

この答えは、Pythonの「公式」CPython実装に基づいています。他の実装（Jython、PyPy、IronPythonなど）の詳細は異なる場合があります。ありがとう@JörgWMittag これを指摘してくれて 。

100
MSeifert

リストアイテムをシャッフルすると、参照のローカリティが低下し、キャッシュのパフォーマンスが低下します。

リストをコピーすると、オブジェクトではなく参照のみがコピーされるため、ヒープ上のそれらの場所は問題ではないと考えるかもしれません。ただし、コピーには、refcountを変更するために各オブジェクトにアクセスする必要があります。

22
augurar

他の人が説明したように、参照をコピーするだけでなく、オブジェクト内の参照カウントを増やすため、オブジェクトがアクセスされ、キャッシュが役割を果たします。

ここで、さらに実験を追加します。シャッフルされたものとシャッフルされていないものについてはあまり関係ありません（1つの要素にアクセスするとキャッシュが失われる可能性がありますが、次の要素をキャッシュに入れるとヒットします）。ただし、要素がキャッシュに残っているために同じ要素に後でアクセスするとキャッシュにヒットする可能性のある要素の繰り返しについては。

通常の範囲のテスト：

>>> from timeit import timeit
>>> a = range(10**7)
>>> [timeit(lambda: list(a), number=100) for _ in range(3)]
[5.1915339142808925, 5.1436351868889645, 5.18055115701749]

同じサイズであるが、1つの要素のみが繰り返し繰り返されるリストは、常にキャッシュにヒットするため、より高速です。

>>> a = [0] * 10**7
>>> [timeit(lambda: list(a), number=100) for _ in range(3)]
[4.125743135926939, 4.128927210087596, 4.0941229388550795]

そして、それが何の数であるかは重要ではないようです：

>>> a = [1234567] * 10**7
>>> [timeit(lambda: list(a), number=100) for _ in range(3)]
[4.124106479141709, 4.156590225249886, 4.219242600790949]

興味深いことに、代わりに同じ2つまたは4つの要素を繰り返すと、さらに高速になります。

>>> a = [0, 1] * (10**7 / 2)
>>> [timeit(lambda: list(a), number=100) for _ in range(3)]
[3.130586101607932, 3.1001001764957294, 3.1318465707127814]

>>> a = [0, 1, 2, 3] * (10**7 / 4)
>>> [timeit(lambda: list(a), number=100) for _ in range(3)]
[3.096105435911994, 3.127148431279352, 3.132872673690855]

同じカウンタが常に増加しているのが気に入らないと思います。たぶん、いくつかの パイプラインストール は、各増加が前の増加の結果を待つ必要があるためです。

とにかく、さらに多くの繰り返し要素に対してこれを試してください：

from timeit import timeit
for e in range(26):
    n = 2**e
    a = range(n) * (2**25 / n)
    times = [timeit(lambda: list(a), number=20) for _ in range(3)]
    print '%8d ' % n, '  '.join('%.3f' % t for t in times), ' => ', sum(times) / 3

出力（最初の列はさまざまな要素の数で、それぞれ3回テストして平均を取る）：

       1  2.871  2.828  2.835  =>  2.84446732686
       2  2.144  2.097  2.157  =>  2.13275338734
       4  2.129  2.297  2.247  =>  2.22436720645
       8  2.151  2.174  2.170  =>  2.16477771575
      16  2.164  2.159  2.167  =>  2.16328197911
      32  2.102  2.117  2.154  =>  2.12437970598
      64  2.145  2.133  2.126  =>  2.13462250728
     128  2.135  2.122  2.137  =>  2.13145065221
     256  2.136  2.124  2.140  =>  2.13336283943
     512  2.140  2.188  2.179  =>  2.1688431668
    1024  2.162  2.158  2.167  =>  2.16208440826
    2048  2.207  2.176  2.213  =>  2.19829998424
    4096  2.180  2.196  2.202  =>  2.19291917834
    8192  2.173  2.215  2.188  =>  2.19207065277
   16384  2.258  2.232  2.249  =>  2.24609975704
   32768  2.262  2.251  2.274  =>  2.26239771771
   65536  2.298  2.264  2.246  =>  2.26917420394
  131072  2.285  2.266  2.313  =>  2.28767871168
  262144  2.351  2.333  2.366  =>  2.35030805124
  524288  2.932  2.816  2.834  =>  2.86047313113
 1048576  3.312  3.343  3.326  =>  3.32721167007
 2097152  3.461  3.451  3.547  =>  3.48622758473
 4194304  3.479  3.503  3.547  =>  3.50964316455
 8388608  3.733  3.496  3.532  =>  3.58716466865
16777216  3.583  3.522  3.569  =>  3.55790996695
33554432  3.550  3.556  3.512  =>  3.53952594744

そのため、単一の（繰り返される）要素の約2.8秒から、2、4、8、16、...の異なる要素の約2.2秒に低下し、10万まで約2.2秒のままです。これは私のL2キャッシュを使用すると思います（4×256 KB、私は i7-67 を持っています）。

その後、数ステップにわたって、時間が3.5秒になります。私は、これが「使い果たされる」まで、L2キャッシュとL3キャッシュ（8 MB）の混合を使用すると思います。

最終的には、キャッシュは約3.5秒のままになります。これは、キャッシュが繰り返しの要素をサポートしなくなるためです。

5
Stefan Pochmann

シャッフルの前に、ヒープに割り当てられると、隣接するインデックスオブジェクトはメモリ内で隣接し、アクセスされるとメモリヒット率が高くなります。シャッフル後、新しいリストの隣接するインデックスのオブジェクトはメモリにありません。隣接して、ヒット率は非常に低いです。

0
xws