Python kodu neden bir işlevde daha hızlı çalışır?

def main():
    for i in xrange(10**8):
        pass
main()

Python'daki bu kod parçası çalışır (Not: Zamanlama Linux'ta BASH'daki zaman işleviyle yapılır.)

real    0m1.841s
user    0m1.828s
sys     0m0.012s

Ancak, for döngüsü bir işlev içine yerleştirilmezse,

for i in xrange(10**8):
    pass

daha uzun süre çalışır:

real    0m4.543s
user    0m4.524s
sys     0m0.012s

Bu neden?

Yerel değişkenleri depolamanın neden küresellerden daha hızlı olduğunu sorabilirsiniz . Bu bir CPython uygulama detayıdır.

CPython'un yorumlayıcının çalıştığı bayt koduna derlendiğini unutmayın. Bir fonksiyon derlenince, lokal değişkenler (sabit boyutlu bir dizide olmayan bir dict) ve değişken isimleri dizinler atanır. Bu, bir işleve dinamik olarak yerel değişkenler ekleyemediğiniz için mümkündür. Daha sonra yerel bir değişken almak, kelimenin tam anlamıyla listeye bir işaretçi araması ve üzerinde PyObjectönemsiz olan bir yeniden sayım artışıdır .

Bunu LOAD_GLOBAL, dictkarma ve benzeri gerçek bir arama olan global bir aramayla ( ) karşılaştırın. Bu nedenle, bu nedenle global iglobal olmasını isteyip istemediğinizi belirtmeniz gerekir : bir kapsam içindeki bir değişkene atadığınızda, derlemez, STORE_FASTsiz söylemezseniz erişim için s gönderir .

Bu arada, küresel aramalar hala oldukça optimize edilmiştir. Özellik aramaları foo.barvardır gerçekten yavaş olanlar!

Yerel değişken verimlilik üzerine küçük bir örnek .

Bir işlevin içinde bayt kodu:

  2           0 SETUP_LOOP              20 (to 23)
              3 LOAD_GLOBAL              0 (xrange)
              6 LOAD_CONST               3 (100000000)
              9 CALL_FUNCTION            1
             12 GET_ITER            
        >>   13 FOR_ITER                 6 (to 22)
             16 STORE_FAST               0 (i)

  3          19 JUMP_ABSOLUTE           13
        >>   22 POP_BLOCK           
        >>   23 LOAD_CONST               0 (None)
             26 RETURN_VALUE        

En üst düzeyde, bayt kodu:

  1           0 SETUP_LOOP              20 (to 23)
              3 LOAD_NAME                0 (xrange)
              6 LOAD_CONST               3 (100000000)
              9 CALL_FUNCTION            1
             12 GET_ITER            
        >>   13 FOR_ITER                 6 (to 22)
             16 STORE_NAME               1 (i)

  2          19 JUMP_ABSOLUTE           13
        >>   22 POP_BLOCK           
        >>   23 LOAD_CONST               2 (None)
             26 RETURN_VALUE        

Fark, STORE_FASTdaha hızlı (!) Olmasıdır STORE_NAME. Bunun nedeni, bir işlevde, iyerel bir değerdir ancak en üst düzeyde bir küresel olmasıdır.

Bayt kodunu incelemek için dismodülü kullanın . Fonksiyonu doğrudan sökebildim, ancak üst düzey kodu sökmek için compileyerleşik'i kullanmak zorunda kaldım .

Yerel / global değişken mağaza sürelerinin yanı sıra, opcode tahmini işlevi daha hızlı hale getirir.

Diğer cevapların açıkladığı gibi, fonksiyon STORE_FASTdöngüdeki opcode'u kullanır . İşte işlevin döngüsü için bayt kodu:

    >>   13 FOR_ITER                 6 (to 22)   # get next value from iterator
         16 STORE_FAST               0 (x)       # set local variable
         19 JUMP_ABSOLUTE           13           # back to FOR_ITER

Normalde bir program çalıştırıldığında, Python her opcode'u birbiri ardına yürütür, bir yığının kaydını tutar ve her opcode yürütüldükten sonra yığın karesinde diğer kontrolleri önceden yapar. Opcode tahmini, bazı durumlarda Python'un bir sonraki opcode'a doğrudan atlayabileceği ve böylece bu ek yükün bir kısmından kaçınabileceği anlamına gelir.

Bu durumda, Python her FOR_ITERdöngüde (döngünün üst kısmı) her gördüğünde STORE_FAST, yürütmesi gereken bir sonraki opcode olan "tahmini" olur. Python daha sonra bir sonraki opcode'a göz atar ve tahmin doğruysa doğrudan doğruya atlar STORE_FAST. Bunun, iki opodu tek bir opcode olarak sıkma etkisi vardır.

Öte yandan, STORE_NAMEopcode döngüde global düzeyde kullanılır. Python, bu opcode'u gördüğünde benzer tahminlerde bulunmaz * . Bunun yerine, döngünün yürütüldüğü hız için belirgin etkileri olan değerlendirme döngüsünün en üstüne geri dönmelidir.

Bu optimizasyon hakkında daha fazla teknik ayrıntı vermek için, ceval.cdosyadan bir alıntı (Python'un sanal makinesinin "motoru"):

Bazı opodlar çiftler halinde gelir, böylece ilk kod çalıştırıldığında ikinci kodu tahmin etmeyi mümkün kılar. Örneğin GET_ITER, genellikle onu takip eder FOR_ITER. Ve FOR_ITERgenellikleSTORE_FAST veya ile devam eder UNPACK_SEQUENCE.

Tahmini doğrulamak, bir kayıt değişkeninin bir sabite karşı tek bir yüksek hızlı testine mal olur. Eşleştirme iyiyse, işlemcinin kendi dahili şube tahmininin yüksek bir başarı olasılığı vardır ve bu da bir sonraki opcode'a neredeyse sıfır ek yüke geçişle sonuçlanır. Başarılı bir tahmin, öngörülemeyen iki dalı olan HAS_ARGtest ve anahtar durumu da dahil olmak üzere eval-loop üzerinden bir yolculuk kaydeder . İşlemcinin dahili şube tahmini ile birleştiğinde, başarılı bir şekilde PREDICT, iki opcodun, gövdeleri birleştirilmiş yeni bir tek opcodemuş gibi çalıştırması etkisi vardır.

FOR_ITEROpcode'un kaynak kodunda tam olarak tahminin STORE_FASTyapıldığı yeri görebiliriz:

case FOR_ITER:                         // the FOR_ITER opcode case
    v = TOP();
    x = (*v->ob_type->tp_iternext)(v); // x is the next value from iterator
    if (x != NULL) {                     
        PUSH(x);                       // put x on top of the stack
        PREDICT(STORE_FAST);           // predict STORE_FAST will follow - success!
        PREDICT(UNPACK_SEQUENCE);      // this and everything below is skipped
        continue;
    }
    // error-checking and more code for when the iterator ends normally                                     

PREDICTFonksiyon için genişler if (*next_instr == op) goto PRED_##opbiz sadece tahmin işlem kodu başlangıcına atlamak yani. Bu durumda, buraya atlıyoruz:

PREDICTED_WITH_ARG(STORE_FAST);
case STORE_FAST:
    v = POP();                     // pop x back off the stack
    SETLOCAL(oparg, v);            // set it as the new local variable
    goto fast_next_opcode;

Yerel değişken ayarlanmıştır ve bir sonraki opcode yürütülmeye hazırdır. Python her seferinde başarılı bir tahminde bulunarak sonuna kadar tekrarlanabilir.

Python wiki sayfası CPython sanal makine nasıl çalıştığı hakkında daha fazla bilgi vardır.