Mengapa kode Python berjalan lebih cepat dalam suatu fungsi?

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

Sepotong kode dalam Python ini berjalan di (Catatan: Pengaturan waktu dilakukan dengan fungsi waktu dalam BASH di Linux.)

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

Namun, jika for loop tidak ditempatkan dalam suatu fungsi,

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

kemudian berjalan untuk waktu yang lebih lama:

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

Kenapa ini?

Anda mungkin bertanya mengapa lebih cepat menyimpan variabel lokal daripada global. Ini adalah detail implementasi CPython.

Ingat bahwa CPython dikompilasi ke bytecode, yang dijalankan oleh interpreter. Ketika suatu fungsi dikompilasi, variabel lokal disimpan dalam array ukuran tetap ( bukan a dict) dan nama variabel ditugaskan ke indeks. Ini dimungkinkan karena Anda tidak dapat menambahkan variabel lokal secara dinamis ke suatu fungsi. Kemudian mengambil variabel lokal secara harfiah adalah pencarian pointer ke dalam daftar dan peningkatan jumlah referensi PyObjectyang sepele.

Bandingkan ini dengan pencarian global ( LOAD_GLOBAL), yang merupakan dictpencarian sebenarnya yang melibatkan hash dan sebagainya. Kebetulan, inilah mengapa Anda perlu menentukan global iapakah Anda ingin menjadi global: jika Anda pernah menetapkan variabel di dalam lingkup, kompiler akan mengeluarkan STORE_FASTs untuk aksesnya kecuali jika Anda tidak melakukannya.

Omong-omong, pencarian global masih cukup optimal. Pencarian atribut foo.baradalah yang sangat lambat!

Berikut adalah ilustrasi kecil tentang efisiensi variabel lokal.

Di dalam suatu fungsi, bytecode adalah:

  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        

Di tingkat atas, bytecode adalah:

  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        

Perbedaannya adalah bahwa STORE_FASTlebih cepat (!) Daripada STORE_NAME. Ini karena dalam suatu fungsi, iadalah lokal tetapi pada tingkat atas itu adalah global.

Untuk memeriksa bytecode, gunakan dismodul . Saya dapat membongkar fungsi secara langsung, tetapi untuk membongkar kode tingkat atas saya harus menggunakan compilebuiltin .

Selain waktu penyimpanan variabel lokal / global, prediksi opcode membuat fungsi lebih cepat.

Seperti jawaban lain menjelaskan, fungsi menggunakan STORE_FASTopcode di loop. Inilah bytecode untuk loop fungsi:

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

Biasanya ketika sebuah program dijalankan, Python mengeksekusi setiap opcode satu demi satu, melacak stack dan melakukan preforming cek lainnya pada frame stack setelah setiap opcode dieksekusi. Prediksi opcode berarti bahwa dalam kasus-kasus tertentu Python dapat melompat langsung ke opcode berikutnya, sehingga menghindari beberapa overhead ini.

Dalam hal ini, setiap kali Python melihat FOR_ITER(bagian atas loop), itu akan "memprediksi" itu STORE_FASTadalah opcode berikutnya yang harus dijalankan. Python kemudian mengintip opcode berikutnya dan, jika prediksi itu benar, ia langsung melompat STORE_FAST. Ini memiliki efek memeras dua opcode menjadi satu opcode tunggal.

Di sisi lain, STORE_NAMEopcode digunakan dalam loop di tingkat global. Python tidak * tidak * membuat prediksi serupa ketika melihat opcode ini. Sebaliknya, itu harus kembali ke atas evaluasi-loop yang memiliki implikasi yang jelas untuk kecepatan di mana loop dieksekusi.

Untuk memberikan detail teknis lebih lanjut tentang optimasi ini, berikut adalah kutipan dari ceval.cfile ("mesin" mesin virtual Python):

Beberapa opcode cenderung berpasangan sehingga memungkinkan untuk memprediksi kode kedua ketika yang pertama dijalankan. Misalnya, GET_ITERsering diikuti oleh FOR_ITER. Dan FOR_ITERsering diikuti olehSTORE_FAST atau UNPACK_SEQUENCE.

Memverifikasi biaya prediksi uji tunggal berkecepatan tinggi dari variabel register terhadap konstanta. Jika pasangan itu baik, maka predikasi cabang internal prosesor sendiri memiliki kemungkinan keberhasilan yang tinggi, menghasilkan transisi hampir nol-overhead ke opcode berikutnya. Prediksi yang berhasil menghemat perjalanan melalui eval-loop termasuk dua cabangnya yang tidak dapat diprediksi, HAS_ARGtes dan switch-case. Dikombinasikan dengan prediksi cabang internal prosesor, sukses PREDICTmemiliki efek membuat dua opcode berjalan seolah-olah mereka adalah opcode baru tunggal dengan tubuh digabungkan.

Kita dapat melihat dalam kode sumber untuk FOR_ITERopcode di mana prediksi STORE_FASTdibuat:

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                                     

The PREDICTFungsi memperluas untuk if (*next_instr == op) goto PRED_##opyaitu kita hanya melompat ke awal dari opcode diprediksi. Dalam hal ini, kita lompat ke sini:

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;

Variabel lokal sekarang diatur dan opcode berikutnya siap untuk dieksekusi. Python terus melalui iterable hingga mencapai akhir, membuat prediksi sukses setiap saat.

The halaman wiki Python memiliki informasi lebih lanjut tentang bagaimana mesin virtual CPython ini bekerja.