Dlaczego kod Pythona działa szybciej w funkcji?

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

Ten fragment kodu w Pythonie jest uruchamiany (Uwaga: synchronizacja odbywa się za pomocą funkcji czasu w BASH w systemie Linux).

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

Jeśli jednak pętla for nie jest umieszczona w funkcji,

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

wtedy działa znacznie dłużej:

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

Dlaczego to?

Możesz zapytać, dlaczego przechowywanie zmiennych lokalnych jest szybsze niż globals. Jest to szczegół implementacji CPython.

Pamiętaj, że CPython jest kompilowany do kodu bajtowego, który działa interpreter. Gdy funkcja jest kompilowana, zmienne lokalne są przechowywane w tablicy o stałym rozmiarze ( nie a dict), a nazwy zmiennych są przypisywane do indeksów. Jest to możliwe, ponieważ nie można dynamicznie dodawać zmiennych lokalnych do funkcji. Następnie pobranie zmiennej lokalnej jest dosłownie wyszukiwaniem wskaźnika na liście i wzrostem liczby rachunków, PyObjectco jest banalne.

Porównaj to z globalnym wyszukiwaniem ( LOAD_GLOBAL), które jest prawdziwym dictwyszukiwaniem obejmującym skrót i tak dalej. Nawiasem mówiąc, dlatego musisz określić, global iczy chcesz, aby była globalna: jeśli kiedykolwiek przypiszesz zmienną wewnątrz zakresu, kompilator wyda STORE_FASTs o dostęp, chyba że powiesz, żeby tego nie robiła.

Nawiasem mówiąc, globalne wyszukiwania są nadal dość zoptymalizowane. Wyszukiwanie atrybutów foo.barjest naprawdę powolne!

Oto mała ilustracja na temat lokalnej zmiennej wydajności.

Wewnątrz funkcji kod bajtowy to:

  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        

Na najwyższym poziomie kod bajtowy to:

  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        

Różnica polega na tym, że STORE_FASTjest szybszy (!) Niż STORE_NAME. Jest tak, ponieważ w funkcjii jest lokalny, ale na najwyższym poziomie jest globalny.

Aby sprawdzić kod bajtowy, użyj dismodułu . Byłem w stanie zdemontować funkcję bezpośrednio, ale aby zdemontować kod najwyższego poziomu musiałem użyć compilewbudowanego .

Oprócz lokalnych / globalnych czasów przechowywania zmiennych, przewidywanie kodu operacyjnego przyspiesza działanie.

Jak wyjaśniają inne odpowiedzi, funkcja wykorzystuje STORE_FASTw pętli kod operacji. Oto kod bajtowy dla pętli funkcji:

    >>   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

Zwykle po uruchomieniu programu Python wykonuje kolejno każdy kod operacji, śledząc stos i wykonując inne kontrole w ramce stosu po wykonaniu każdego kodu operacji. Prognozowanie kodu operacyjnego oznacza, że ​​w niektórych przypadkach Python może przejść bezpośrednio do następnego kodu operacyjnego, unikając w ten sposób części tego narzutu.

W takim przypadku za każdym razem, gdy Python widzi FOR_ITER(górna część pętli), „przewiduje”, że STORE_FASTjest to kolejny kod operacji, który musi wykonać. Python następnie zerknie na następny kod operacji, a jeśli prognoza była poprawna, skacze prosto do STORE_FAST. To powoduje ściśnięcie dwóch kodów operacyjnych w jeden kod operacji.

Z drugiej strony STORE_NAMEopcode jest używany w pętli na poziomie globalnym. Python * nie * robi podobnych prognoz, gdy widzi ten kod operacji. Zamiast tego musi wrócić do górnej części pętli oceny, co ma oczywiste implikacje dla prędkości, z jaką pętla jest wykonywana.

Aby podać więcej szczegółów technicznych na temat tej optymalizacji, oto cytat z ceval.cpliku („silnik” maszyny wirtualnej Pythona):

Niektóre kody są zwykle parami, dzięki czemu można przewidzieć drugi kod podczas pierwszego uruchomienia. Na przykład GET_ITERczęsto występuje po nim FOR_ITER. I FOR_ITERczęsto następuje po nimSTORE_FAST lub UNPACK_SEQUENCE.

Weryfikacja prognozy kosztuje pojedynczy szybki test zmiennej rejestru na stałą. Jeśli parowanie było dobre, wówczas predykcja wewnętrznej gałęzi procesora ma duże prawdopodobieństwo powodzenia, co powoduje prawie zerowe przejście do następnego kodu operacji. Udane przewidywanie oszczędza podróż przez pętlę eval, w tym jej dwie nieprzewidywalne gałęzie, HAS_ARGtest i obudowę przełącznika. W połączeniu z przewidywaniem wewnętrznej gałęzi procesora, sukces PREDICTpowoduje, że dwa kody operacyjne działają tak, jakby były pojedynczym nowym kodem operacyjnym z połączonymi ciałami.

Widzimy w kodzie źródłowym FOR_ITERopcode dokładnie, gdzie dokonano prognozy STORE_FAST:

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                                     

PREDICTFunkcja rozszerza się if (*next_instr == op) goto PRED_##op, czyli po prostu przeskoczyć do początku przewidywanej opcode. W tym przypadku przeskakujemy tutaj:

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;

Zmienna lokalna jest teraz ustawiona i następny kod operacji jest gotowy do wykonania. Python kontynuuje iterowalność aż do końca, dzięki czemu za każdym razem dokonuje udanej prognozy.

Strona wiki Python zawiera więcej informacji na temat działania maszyny wirtualnej CPython.