Proses(atau tugas) ialah abstraksi yang menerangkan program yang sedang berjalan.

Untuk OS proses mewakili unit kerja, permintaan untuk penggunaan sumber sistem. Subsistem pengurusan proses menjadualkan pelaksanaan proses, i.e. mengagihkan masa pemproses antara beberapa proses sedia ada secara serentak dalam sistem, dan juga berurusan dengan penciptaan dan pemusnahan proses, menyediakan proses dengan sumber sistem yang diperlukan, dan menyokong interaksi antara proses.

Sesetengah sumber diperuntukkan kepada proses apabila ia dibuat, dan sebahagian lagi diperuntukkan secara dinamik berdasarkan permintaan pada masa jalan. Sumber boleh diagihkan kepada proses sepanjang hayatnya atau hanya untuk tempoh tertentu. Apabila melaksanakan fungsi ini, subsistem pengurusan proses berinteraksi dengan subsistem OS lain yang bertanggungjawab untuk pengurusan sumber, seperti subsistem pengurusan memori, subsistem input/output dan sistem fail. Apabila beberapa tugas bebas dilakukan serentak dalam sistem, masalah timbul. masalah tambahan. Walaupun proses timbul dan dilaksanakan secara tidak segerak, mereka mungkin perlu berinteraksi, seperti semasa bertukar-tukar data. Kelajuan proses pemadanan juga sangat penting untuk mengelakkan keadaan perlumbaan di mana pelbagai proses cuba mengubah suai fail yang sama, kebuntuan atau perlanggaran lain yang berlaku apabila berkongsi sumber. Penyegerakan proses adalah salah satu fungsi penting subsistem pengurusan proses.

Setiap kali proses tamat, subsistem pengurusan proses menutup semua fail yang proses itu berfungsi, membebaskan kawasan RAM yang diperuntukkan untuk kod, data dan struktur maklumat sistem bagi proses tersebut. Semua kemungkinan baris gilir OS dan senarai sumber yang mengandungi rujukan kepada proses yang ditamatkan diperbetulkan.

Untuk menyokong multiprogramming, OS mesti mentakrifkan dan mereka bentuk untuk dirinya sendiri unit kerja dalaman yang antara pemproses dan sumber komputer lain akan dibahagikan. Perlu diingatkan bahawa multiprogramming adalah satu cara berorganisasi proses pengkomputeran, di mana memori komputer mengandungi beberapa atur cara yang dilaksanakan secara bergantian pada satu pemproses.

Pada masa ini, kebanyakan sistem pengendalian mentakrifkan dua jenis unit kerja. Unit kerja yang lebih besar, biasanya dipanggil proses atau tugas, memerlukan beberapa kerja yang lebih kecil untuk disiapkan, dirujuk sebagai benang atau benang.

Jelas sekali, sebarang operasi sistem komputer terdiri daripada melaksanakan beberapa program. Oleh itu, kod program tertentu dikaitkan dengan kedua-dua proses dan utas, yang untuk tujuan ini direka bentuk dalam bentuk modul boleh laku. Untuk membolehkan kod program ini dilaksanakan, ia mesti dimuatkan ke dalam RAM, mungkin beberapa ruang cakera diperuntukkan untuk penyimpanan data, akses kepada peranti input/output, cth. port bersiri. Semasa pelaksanaan, program juga mungkin memerlukan akses kepada HI, seperti fail. Dan, sudah tentu, adalah mustahil untuk melaksanakan program tanpa menyediakannya masa CPU, iaitu masa semasa pemproses melaksanakan kod program tertentu.

Dalam sistem di mana kedua-dua proses dan utas wujud, proses itu dianggap oleh OS sebagai permintaan untuk menggunakan semua jenis sumber, kecuali untuk satu masa pemproses. Sumber paling penting terakhir ini diedarkan oleh OS antara unit kerja lain - benang, yang mendapat namanya kerana fakta bahawa ia mewakili urutan (benang pelaksanaan) arahan.

Dalam kes paling mudah, proses terdiri daripada satu utas, dan ini adalah bagaimana konsep "proses" ditafsirkan sehingga pertengahan 1980-an, dan dalam bentuk yang sama ia telah dipelihara dalam beberapa sistem pengendalian moden. Dalam sistem jenis ini, konsep "aliran" sepenuhnya diserap oleh konsep "proses", i.e. Hanya tinggal satu unit kerja dan penggunaan sumber - proses. Multiprogramming dijalankan dalam sistem pengendalian sedemikian pada peringkat proses.

Terdapat tiga keadaan asas untuk proses: sedia, berjalan dan disekat.

Pada sistem pemproses tunggal, hanya satu proses boleh dijalankan. Pada masa yang sama, mungkin terdapat beberapa proses sedia dan disekat menunggu beberapa peristiwa (contohnya, I/O) berlaku. Dalam kes ini, senarai proses sedia disusun mengikut keutamaan.

Untuk mengelakkan proses daripada mengganggu peruntukan sumber, serta merosakkan kod dan data satu sama lain, OS perlu membuat keputusan tugas yang paling penting– mengasingkan satu proses daripada yang lain.

Untuk mencapai matlamat ini, OS menyediakan setiap proses dengan ruang alamat maya yang berasingan supaya tiada proses boleh terus mengakses arahan dan data proses lain.

Proses ruang alamat maya ialah satu set alamat yang boleh dimanipulasi oleh modul program proses.

Sistem pengendalian memetakan ruang alamat maya proses ke memori fizikal proses yang diperuntukkan.

Apabila interaksi diperlukan, proses beralih kepada OS, yang, bertindak sebagai perantara, menyediakan mereka dengan cara komunikasi antara proses - saluran paip, peti mel, bahagian memori yang dikongsi dan beberapa yang lain.

Walau bagaimanapun, dalam sistem yang tidak mempunyai konsep benang, masalah timbul apabila mengatur pengiraan selari dalam proses. Dan keperluan sedemikian mungkin timbul. Sesungguhnya, dengan multiprogramming ia meningkat daya pengeluaran sistem, tetapi proses yang berasingan tidak boleh dilaksanakan lebih cepat daripada dalam mod program tunggal (sebarang perkongsian sumber hanya melambatkan kerja salah seorang peserta disebabkan oleh masa tambahan yang dihabiskan untuk menunggu sumber tersedia). Walau bagaimanapun, aplikasi yang berjalan dalam satu proses mungkin mempunyai keselarian dalaman, yang boleh, pada dasarnya, membolehkan penyelesaiannya dipercepatkan. Jika, sebagai contoh, program menyediakan akses kepada peranti luaran, maka semasa operasi ini adalah mungkin untuk tidak menyekat pelaksanaan keseluruhan proses, tetapi untuk meneruskan pengiraan di cawangan lain program. Menjalankan berbilang kerja secara selari dalam satu aplikasi interaktif meningkatkan kecekapan pengguna. Oleh itu, apabila bekerja dengan editor teks, adalah wajar untuk dapat menggabungkan menaip teks baharu dengan operasi yang memakan masa seperti memformat semula bahagian penting teks, mencetak dokumen atau menyimpannya ke cakera setempat atau jauh.

Benang timbul dalam OS sebagai cara untuk menyelaraskan pengiraan. Sudah tentu, masalah pengiraan selari dalam satu aplikasi boleh diselesaikan menggunakan kaedah tradisional.

pertama, pengaturcara aplikasi boleh mengambil tugas yang kompleks untuk mengatur keselarian dengan memilih subrutin penghantar tertentu dalam aplikasi, yang secara berkala memindahkan kawalan kepada satu atau satu lagi cabang pengiraan. Dalam kes ini, program ini ternyata secara logiknya sangat mengelirukan, dengan banyak pemindahan kawalan, yang secara ketara merumitkan penyahpepijatan dan pengubahsuaiannya.

Kedua, penyelesaiannya adalah untuk mencipta beberapa proses untuk setiap kerja selari untuk satu aplikasi. Walau bagaimanapun, menggunakan alat OS standard untuk mencipta proses tidak membenarkan kami mengambil kira hakikat bahawa proses ini menyelesaikan satu masalah, yang bermakna mereka mempunyai banyak persamaan antara satu sama lain - mereka boleh berfungsi dengan data yang sama, menggunakan kod yang sama segmen, dan dikurniakan hak akses yang sama dan sama kepada sumber sistem komputer.

Dalam OS, bersama-sama dengan proses, mekanisme lain untuk menyelaraskan pengiraan diperlukan, yang akan mengambil kira hubungan rapat antara cabang pengiraan individu bagi aplikasi yang sama.

Untuk tujuan ini, sistem pengendalian moden menawarkan mekanisme multithreading. Pada masa yang sama, unit kerja baru diperkenalkan - benang pelaksanaan dan konsep "proses" mengubah maknanya ke tahap yang ketara. Konsep "benang" sepadan dengan peralihan berurutan pemproses dari satu arahan program ke yang lain. Sistem pengendalian mengagihkan masa pemproses antara benang. OS memperuntukkan ruang alamat dan satu set sumber kepada proses yang dikongsi antara semua urutannya.

Dalam sistem program tunggal tidak perlu memperkenalkan konsep yang menunjukkan unit kerja, kerana tidak ada masalah pembahagian sumber.

Mencipta benang memerlukan kurang overhed daripada OS daripada proses. Tidak seperti proses yang dimiliki oleh aplikasi bersaing yang berbeza, semua rangkaian satu proses sentiasa tergolong dalam aplikasi yang sama, jadi OS mengasingkan utas pada tahap yang lebih rendah daripada proses dalam sistem berbilang program tradisional. Semua urutan satu proses menggunakan fail biasa, pemasa, peranti, kawasan RAM yang sama, dan ruang alamat yang sama. Ini bermakna mereka berkongsi pembolehubah global yang sama. Oleh kerana setiap utas boleh mengakses mana-mana alamat maya sesuatu proses, satu utas boleh menggunakan timbunan utas lain. Tidak ada perlindungan lengkap antara benang proses yang sama, kerana, pertama, mustahil, dan kedua, tidak perlu. Untuk mengatur interaksi dan pertukaran data, utas tidak perlu mengakses OS sama sekali, mereka hanya perlu menggunakan memori yang dikongsi - satu utas menulis data, dan satu lagi membacanya. Sebaliknya, mengalir proses yang berbeza masih dilindungi dengan baik antara satu sama lain.

Pengaturcaraan berbilang lebih cekap pada tahap benang dan bukannya tahap proses. Setiap utas mempunyai pembilang program dan timbunan sendiri. Tugasan yang direka bentuk sebagai beberapa utas dalam satu proses boleh diselesaikan dengan lebih cepat disebabkan oleh pelaksanaan pseudo-selari (atau selari dalam sistem berbilang pemproses) bahagian-bahagiannya. Multithreading boleh digunakan terutamanya dengan berkesan untuk menjalankan aplikasi yang diedarkan sebagai contoh, pelayan multithreading boleh melaksanakan permintaan daripada berbilang klien secara selari.

Penggunaan benang dikaitkan bukan sahaja dengan keinginan untuk meningkatkan prestasi sistem melalui pengkomputeran selari, tetapi juga dengan matlamat untuk mencipta program logik yang lebih mudah dibaca. Pengenalan pelbagai utas pelaksanaan memudahkan pengaturcaraan. Contohnya, dalam tugasan pembaca-penulis, satu utas menulis kepada penimbal dan satu lagi membaca daripadanya. Memandangkan mereka berkongsi penimbal biasa, anda tidak sepatutnya melakukannya proses berasingan. Satu lagi contoh menggunakan benang adalah untuk mengawal isyarat seperti sampukan papan kekunci (Del atau Break). Daripada mengendalikan isyarat gangguan, satu utas ditugaskan untuk sentiasa menunggu isyarat tiba. Oleh itu, menggunakan benang boleh mengurangkan keperluan untuk gangguan peringkat pengguna. Dalam contoh ini, pelaksanaan selari tidak sepenting kejelasan program.

Kesan terbesar daripada pengenalan pemprosesan berbilang benang dicapai dalam sistem berbilang pemproses, di mana utas, termasuk yang tergolong dalam proses yang sama, boleh dilaksanakan pada pemproses berbeza yang benar-benar selari (dan bukan selari pseudo).

Buat proses Pertama sekali, ini bermakna mencipta deskriptor proses, iaitu satu atau lebih struktur maklumat yang mengandungi semua maklumat tentang proses yang diperlukan untuk OS mengurusnya. Maklumat sedemikian mungkin termasuk, sebagai contoh, pengecam proses, maklumat tentang lokasi memori modul boleh laku, tahap keistimewaan proses (keutamaan dan hak akses), dsb.

Contoh deskriptor proses ialah Blok Kawalan Tugas (TCB) dalam OS/360, Blok Kawalan Proses (PCB) dalam OS/2, pengendalian proses dalam UNIX, proses objek dalam Windows NT .

Penciptaan deskriptor proses menandakan kemunculan pesaing lain untuk sumber pengkomputeran dalam sistem. Mulai saat ini, OS mesti mengambil kira keperluan proses baharu apabila memperuntukkan sumber.

Mencipta proses melibatkan memuatkan kod dan data program boleh laku proses ini daripada cakera ke RAM. Untuk melakukan ini, OS mesti mengesan lokasi program sedemikian pada cakera, memperuntukkan semula RAM, dan memperuntukkan memori kepada program boleh laku proses baharu. Kemudian adalah perlu untuk membaca program ke dalam kawasan memori yang diperuntukkan untuknya dan, mungkin, menukar parameter program bergantung pada lokasi dalam memori.

Dalam sistem dengan memori maya, hanya sebahagian daripada kod proses dan data boleh dimuatkan pada saat awal, untuk "membesarkan" selebihnya seperti yang diperlukan. Terdapat sistem di mana, pada peringkat penciptaan proses, ia tidak semestinya memuatkan kod dan data ke dalam RAM sebaliknya, modul boleh laku disalin daripada direktori tersebut sistem fail, di mana ia terletak pada asalnya, ke kawasan swap - kawasan khas cakera yang diperuntukkan untuk menyimpan kod proses dan data. Dalam melaksanakan semua tindakan ini, subsistem pengurusan proses berinteraksi rapat dengan subsistem pengurusan memori dan sistem fail.

Dalam sistem berbilang benang, apabila proses dibuat, OS mencipta sekurang-kurangnya satu urutan pelaksanaan untuk setiap proses. Apabila mencipta benang, sama seperti semasa membuat proses, OS menjana struktur maklumat khas - deskriptor benang, yang mengandungi pengecam benang, hak akses dan data keutamaan, keadaan benang dan maklumat lain. Dalam keadaan awal, benang (atau proses, jika kita bercakap tentang sistem di mana konsep "benang" tidak ditakrifkan) berada dalam keadaan digantung. Saat memilih benang untuk pelaksanaan dijalankan mengikut peraturan untuk menyediakan masa pemproses yang diterima dalam sistem ini dan mengambil kira semua yang sedia ada. masa ini benang dan proses. Jika kod proses dan data berada dalam kawasan swap, syarat yang diperlukan untuk mengaktifkan benang proses juga ialah kehadiran ruang dalam RAM untuk memuatkan modul boleh lakunya.

Pada banyak sistem, benang boleh meminta OS membuat apa yang dipanggil aliran keturunan. Sistem pengendalian yang berbeza menstrukturkan hubungan antara benang kanak-kanak dan ibu bapa mereka secara berbeza. Sebagai contoh, dalam sesetengah sistem pengendalian, pelaksanaan benang induk disegerakkan dengan keturunannya, khususnya selepas selesai benang induk, OS boleh berhenti melaksanakan semua keturunannya. Pada sistem lain, utas anak mungkin dilaksanakan secara tak segerak berkenaan dengan utas induk. Keturunan biasanya mewarisi banyak sifat aliran induk mereka. Dalam banyak sistem, pemijahan anak adalah mekanisme utama untuk mencipta proses dan benang.

Perancangan proses termasuk menyelesaikan tugas berikut:

■ penentuan detik masa untuk mengubah proses yang dilakukan;

■ memilih proses untuk dilaksanakan daripada barisan proses sedia;

■ menukar konteks proses "lama" dan "baru".

Dua masalah pertama diselesaikan perisian, dan yang terakhir ini sebahagian besarnya berasaskan perkakasan.

Terdapat banyak algoritma perancangan proses yang berbeza yang menyelesaikan masalah yang disenaraikan dengan cara yang berbeza, mengejar matlamat yang berbeza dan menyediakan kualiti berbilang pengaturcaraan yang berbeza. Di antara set algoritma ini, mari kita lihat dengan lebih dekat dua kumpulan algoritma yang paling biasa: algoritma berasaskan kuantiti dan algoritma berasaskan keutamaan.

Sesuai dengan algoritma berdasarkan kuantisasi, perubahan proses aktif berlaku jika:

■ proses tamat dan meninggalkan sistem;

■ ralat berlaku;

■ proses telah memasuki keadaan "menunggu";

■ kepingan masa pemproses yang diperuntukkan untuk proses ini telah habis.

Proses yang telah kehabisan kuantumnya diletakkan dalam keadaan "sedia" dan menunggu kuantum masa pemproses baharu diberikan kepadanya, dan dipilih untuk dilaksanakan mengikut peraturan tertentu. proses baru dari barisan yang sedia. Dengan cara ini, tiada proses yang menduduki CPU untuk masa yang lama, itulah sebabnya pengkuantitian digunakan secara meluas dalam sistem perkongsian masa.

Kuanta yang diperuntukkan kepada proses boleh sama untuk semua proses atau berbeza. Kuanta yang diperuntukkan kepada satu proses boleh mempunyai nilai tetap atau berbeza-beza pada tempoh yang berbeza dalam hayat proses. Proses yang belum menggunakan sepenuhnya kuantum yang diperuntukkan kepada mereka (contohnya, disebabkan oleh aktiviti I/O) mungkin atau mungkin tidak menerima pampasan dalam bentuk keistimewaan semasa penyelenggaraan berikutnya. Barisan proses sedia boleh disusun dengan cara yang berbeza: secara kitaran, mengikut peraturan "masuk dahulu, keluar dahulu" (FIFO) atau mengikut peraturan "masuk terakhir, keluar dahulu" (LIFO).

DALAM algoritma berasaskan keutamaan konsep "keutamaan" proses digunakan.

Keutamaan– ini ialah nombor yang mencirikan tahap keistimewaan proses apabila menggunakan sumber komputer, khususnya masa CPU: semakin tinggi keutamaan, semakin tinggi keistimewaannya.

Keutamaan boleh dinyatakan sebagai nilai integer atau pecahan, positif atau negatif. Semakin tinggi keistimewaan sesuatu proses, semakin sedikit masa yang akan dihabiskan dalam baris gilir. Keutamaan boleh diberikan secara langsung oleh pentadbir sistem bergantung pada kepentingan kerja atau bayaran yang dibayar, atau dikira oleh OS itu sendiri mengikut peraturan tertentu ia boleh kekal tetap sepanjang hayat proses atau berubah mengikut masa mengikut; beberapa undang-undang. Dalam kes kedua, keutamaan dipanggil dinamik.

Terdapat dua jenis algoritma keutamaan: algoritma yang menggunakan keutamaan relatif dan algoritma yang menggunakan keutamaan mutlak.

Dalam kedua-dua kes, pemilihan proses untuk pelaksanaan daripada baris gilir sedia dijalankan dengan cara yang sama: proses dengan keutamaan tertinggi dipilih. Masalah menentukan momen perubahan proses aktif diselesaikan dengan cara yang berbeza. Dalam sistem keutamaan relatif Proses aktif berjalan sehingga ia meninggalkan pemproses itu sendiri, masuk ke keadaan "menyekat" (atau ralat berlaku, atau proses tamat). Dalam sistem dengan keutamaan mutlak pelaksanaan proses aktif terganggu di bawah satu lagi syarat: jika proses muncul dalam baris gilir proses sedia yang keutamaannya lebih tinggi daripada keutamaan proses aktif. Dalam kes ini, proses yang terganggu masuk ke keadaan sedia.

Dalam kebanyakan sistem pengendalian, algoritma penjadualan dibina menggunakan pengkuantitian dan keutamaan. Sebagai contoh, penjadualan adalah berdasarkan kuantum, tetapi nilai kuantum dan (atau) susunan proses dipilih daripada baris gilir yang sedia ditentukan oleh keutamaan proses.

Terdapat dua jenis utama prosedur penjadualan proses: preemptive dan non-preemptive.

Multitasking bukan preemptive(Non-preemptive multitasking) ialah kaedah penjadualan proses di mana proses aktif berjalan sehingga ia, atas inisiatifnya sendiri, memberikan kawalan kepada penjadual OS supaya ia memilih proses lain yang sedia untuk dijalankan daripada baris gilir.

Berbilang tugas awalan(Preemptive multitasking) ialah kaedah di mana keputusan untuk menukar pemproses daripada melaksanakan satu proses kepada melaksanakan yang lain dibuat oleh penjadual OS, dan bukan oleh tugas aktif itu sendiri.

Konsep "preemptive" dan "non-preemptive" kadangkala dikenal pasti dengan konsep keutamaan dan disiplin bukan keutamaan, yang sama sekali tidak betul, serta dengan konsep keutamaan mutlak dan relatif, yang sebahagiannya tidak betul. Berbilang tugas preemptive dan bukan preemptive adalah konsep yang lebih luas daripada jenis keutamaan. Keutamaan tugas mungkin atau mungkin tidak digunakan dalam kedua-dua kaedah penjadualan preemptive dan bukan preemptive. Oleh itu, dalam hal menggunakan keutamaan, disiplin keutamaan relatif boleh diklasifikasikan sebagai kelas sistem dengan multitasking bukan preemptive, dan disiplin keutamaan mutlak boleh diklasifikasikan sebagai kelas sistem dengan multitasking preemptive. Disiplin penjadualan bukan keutamaan, berdasarkan peruntukan potongan masa yang sama untuk semua tugas, merujuk kepada algoritma preemptive.

Perbezaan utama antara multitasking preemptive dan non-preemptive ialah tahap pemusatan mekanisme penjadualan tugas. Pada multitasking preemptive mekanisme penjadualan tugas tertumpu sepenuhnya dalam OS dan pengaturcara menulis aplikasinya tanpa bimbang ia akan dilaksanakan selari dengan tugas lain. Dalam kes ini, OS berfungsi fungsi berikut: menentukan saat apabila tugas aktif dialih keluar daripada pelaksanaan, mengingati konteksnya, memilih daripada baris gilir tugasan siap sedia yang seterusnya dan melancarkannya untuk pelaksanaan, memuatkan konteksnya. Pada multitasking bukan preemptive Mekanisme penjadualan diedarkan antara sistem dan program aplikasi. Program aplikasi, setelah menerima kawalan daripada OS, sendiri menentukan masa penyiapan lelaran seterusnya dan memindahkan kawalan ke OS menggunakan beberapa panggilan sistem, dan OS membentuk baris gilir tugas dan memilih tugas seterusnya untuk pelaksanaan mengikut beberapa algoritma (contohnya, mengambil kira keutamaan) . Mekanisme ini menimbulkan masalah untuk kedua-dua pengguna dan pembangun.

Bagi pengguna, ini bermakna kawalan sistem hilang untuk tempoh masa yang sewenang-wenangnya, yang ditentukan oleh aplikasi (bukan pengguna). Jika aplikasi menghabiskan terlalu banyak masa melakukan beberapa kerja, seperti memformat cakera, pengguna tidak boleh beralih daripada tugas itu kepada tugas lain, seperti penyunting teks, manakala pemformatan akan diteruskan di latar belakang. Keadaan ini tidak diingini kerana pengguna biasanya tidak mahu menunggu lama untuk mesin menyelesaikan tugasnya. Oleh itu, pembangun aplikasi untuk persekitaran operasi preemptive, dengan mengandaikan fungsi penjadual, mesti mencipta aplikasi supaya mereka melaksanakan tugas mereka dalam bahagian kecil. Sebagai contoh, program format boleh memformat satu trek cakera liut dan mengembalikan kawalan kepada sistem. Selepas menyelesaikan tugasan lain, sistem akan mengembalikan kawalan kepada pemformat untuk memformat trek seterusnya. Kaedah membahagikan masa antara tugas ini berfungsi, tetapi ia merumitkan pembangunan program dengan ketara dan meletakkan permintaan yang meningkat pada kelayakan pengaturcara. Pengaturcara mesti memastikan bahawa programnya adalah "mesra" kepada program lain yang berjalan serentak dengannya, memberikan kawalan kepada mereka dengan kerap. Manifestasi melampau "tidak mesra" aplikasi ialah pembekuan, yang membawa kepada ranap sistem umum. Dalam sistem dengan multitasking preemptive, situasi sedemikian biasanya dikecualikan, kerana mekanisme penjadualan pusat akan mengalih keluar tugas yang tersekat daripada pelaksanaan.

Walau bagaimanapun, mengagihkan fungsi penjadual antara sistem dan aplikasi tidak selalunya merugikan, dan dalam keadaan tertentu boleh menjadi kelebihan, kerana ia membolehkan pembangun aplikasi mereka bentuk algoritma penjadualan yang paling sesuai untuk set tugasan tetap tertentu. Memandangkan pembangun sendiri yang menentukan dalam program pada masa yang tepat apabila kawalan dikembalikan, ini menghapuskan gangguan yang tidak rasional terhadap program pada saat-saat yang "tidak selesa". Di samping itu, masalah perkongsian data mudah diselesaikan: tugas menggunakannya secara eksklusif semasa setiap lelaran dan yakin bahawa tiada orang lain akan mengubah data ini dalam tempoh ini. Kelebihan ketara sistem anjakan adalah lebih kelajuan tinggi bertukar dari tugas ke tugas.

Satu contoh penggunaan berkesan multitasking bukan preemptive ialah pelayan fail NetWare, yang sebahagian besarnya berkat ini telah mencapai kelajuan tinggi operasi fail.

Walau bagaimanapun, hampir semua sistem pengendalian moden memfokuskan pada pelaksanaan aplikasi berprestasi tinggi (UNIX, Windows NT, OS/2, VAX/VMS) melaksanakan multitasking preemptive. Baru-baru ini, giliran telah tiba kepada OS kelas desktop. Mungkin atas sebab ini, multitasking preemptive sering dipanggil benar.

7 jawapan

Ini bergantung kepada perkakasan, kerana anda (mungkin) tidak menggunakan komputer teori, tetapi perkakasan fizikal, jadi anda mempunyai sumber yang terhad.

Selain itu, walaupun anda mungkin menjalankan 5000+ utas, bergantung pada perkakasan anda, itu mungkin lebih perlahan daripada program bersamaan 10 utas. Saya fikir anda perlu melihat pengumpulan benang.

Biasanya, bilangan utas yang berjalan serentak ditentukan oleh bilangan pemproses dan teras CPU (termasuk hyperthreading) yang anda miliki. Iaitu, pada bila-bila masa, bilangan benang yang berjalan (dalam sistem pengendalian) adalah sama dengan bilangan "teras".

Berapa banyak utas yang anda boleh jalankan secara serentak dalam aplikasi anda bergantung pada Kuantiti yang besar faktor. Nombor terbaik(orang ringan) akan menjadi bilangan teras pada mesin, tetapi sudah tentu ia seolah-olah tiada siapa yang berpura-pura (tiada aplikasi lain :).

Sejujurnya, saya katakan saya banyak melakukan multithreading dalam .NET/Windows kerana seseorang biasanya melakukan lebih banyak "kerosakan" daripada kebaikan apabila anda tidak mempunyai pemahaman sebenar NET mempunyai konsep kumpulan benang dan anda perlu melakukannya mengetahui cara ia berfungsi sebagai tambahan kepada Windows.

Dalam .NET 3.5/4.0 anda harus melihat Perpustakaan Selari Tugas kerana perpustakaan adalah lebih baik dalam menentukan berapa banyak benang (jika ada) untuk bertelur. Dengan TPL, threadpool mendapat baik pulih besar dan lebih bijak tentang pendaraban benang dan mencuri tugas, dsb. Tetapi anda biasanya bekerja dengan tugas, bukan benang.

Ini adalah kawasan yang kompleks, dan sebagai hasilnya, platform .NET memperkenalkan Tasks untuk menjauhkan pengaturcara daripada benang dan dengan itu membolehkan masa jalan menjadi bijak mengenainya, manakala pengaturcara hanya akan mengatakan apa yang dia mahu dan tidak begitu banyak tentang bagaimana untuk ini.

Setiap benang menggunakan lebih banyak memori (tindanan kernel, blok persekitaran benang, setempat-benang, tindanan....). AFAIK tidak ada had eksplisit pada Windows, jadi hadnya ialah memori (mungkin timbunan setiap benang).

DALAM Benang Linux proses yang lebih serupa (memori dikongsi) dan anda terhad kepada:

Cat /proc/sys/kernel/threads-max

Peraturan praktikal yang cukup baik semasa menjalankan tugas intensif ialah menjalankan nombor yang sama dengan kiraan teras fizikal anda.

Ya, anda boleh menjalankan lebih banyak tugas, tetapi mereka akan menunggu sumber (atau utas dalam kumpulan benang) dan kotak anda, tidak kira saiznya, tidak boleh memperuntukkan sepenuhnya semua sumber CPU utama kepada 100% daripada utas disebabkan latar belakang/ proses lain. Oleh itu, lebih banyak tugasan yang anda buat, lebih banyak utas yang anda buat, memandangkan mereka lebih banyak daripada urutan selari yang mungkin sebenar (1 setiap teras), lebih banyak pengurusan sumber, giliran dan pertukaran akan dilakukan.

Ujian yang kami jalankan sekarang bahawa saya sedang bekerja menggunakan templat virus untuk dijalankan tugas tambahan, menunjukkan bahawa tahap optimum adalah hampir dengan skor pemproses sebagai topi. Tugasan berjalan pada nisbah satu dengan satu dengan bilangan teras fizikal dijalankan selama kira-kira 1 minit setiap tugas. Tetapkan untuk menggandakan kaunter CPU, masa tugas berubah daripada purata 1 minit kepada purata masa 5 minit untuk diselesaikan. Ia menjadi lebih perlahan secara geometri apabila lebih banyak tugas yang dimulakan oleh kernel.

Jadi sebagai contoh, jika anda mempunyai 8 teras fizikal, maka 8 tugasan harus menjadi yang terpantas (dan menggunakan TPL, pada asasnya 8 utas serentak dalam proses yang aktif). Terdapat urutan atau proses utama anda yang mencipta tugas lain dan proses latar belakang lain, tetapi jika kotak itu agak terpencil untuk menikmati penggunaan sumber, ini akan menjadi agak minimum.

Permukaan pengaturcaraan had tugas anda adalah berdasarkan pengiraan teras semasa anda mengunyah tugasan daripada baris gilir atau senarai, jadi semasa anda menggunakan aplikasi ke kotak bersaiz berbeza, ia melaraskan secara automatik.

Untuk menentukan ini secara pemrograman kami gunakan

var CoreCount = System.Environment.ProcessorCount / 2;

Mengapa bahagikan dua, anda bertanya? Kerana hampir semuanya pemproses moden gunakan teras logik atau hyperthread. Anda harus mendapati dengan ujian anda sendiri bahawa jika anda menggunakan kiraan logik, kelajuan keseluruhan anda setiap tugas dan oleh itu keseluruhan proses akan menurun dengan ketara. Teras fizikal adalah kuncinya. Kami tidak dapat melihat cara cepat cari fizikal vs logik tetapi semakan pantas daripada kotak kami telah menunjukkan bahawa ini adalah benar secara konsisten. YMMV, tetapi ini boleh menjadi sangat pantas.

Saya dapat menjalankan 4 utas serentak pada pemproses lama semasa saya (2005). Menggunakan penunu CPU EVGA sebelum buzzer CPU saya berbunyi. (Diprogramkan dalam menu BIOS). Nilai i melebihi 90 * c. Perlu diingat bahawa kita bercakap tentang aliran data yang berjalan serentak. contoh yang baik ialah membuka berbilang program pada masa yang sama. Tetapi secara keseluruhannya ia bergantung pada sejauh mana pemproses anda berfungsi berbilang tugas. (dengan kata lain, banyak benang aktif boleh diproses). Dengan cara yang selamat ujian adalah untuk memuatkan "ocscanner (By EVGA)" dan "CPU Thermometer" menggunakan CPU ke dalam OC Scanner. Semasa menguji, pastikan suhu anda tidak melebihi 90*c (atau apa jua suhu yang anda rasa selamat) dan lihat bilangan benang semasa yang anda lemparkan ke CPU anda. mulakan dengan 2 utas, tunggu 3-5 minit, perhatikan suhu CPU, tambah satu lagi benang, ulangi. (JANGAN TERIMA NASIB ANDA!!!) (JANGAN CUBA JIKA TERMOMETER CPU TIDAK DAPAT MENDAPATKAN SUHU ANDA!!!)

• Tutorial

Dalam artikel ini saya akan cuba menerangkan terminologi yang digunakan untuk menerangkan sistem yang mampu melaksanakan beberapa program secara selari, iaitu multi-core, multi-processor, multi-threaded. Jenis yang berbeza paralelisme dalam CPU IA-32 muncul masa yang berbeza dan dalam susunan yang agak tidak konsisten. Agak mudah untuk keliru dalam semua ini, terutamanya memandangkan sistem pengendalian berhati-hati menyembunyikan butiran daripada program aplikasi yang kurang canggih.

Tujuan artikel itu adalah untuk menunjukkan bahawa dengan semua kepelbagaian kemungkinan konfigurasi sistem berbilang pemproses, berbilang teras dan berbilang benang, untuk program yang dijalankan padanya, peluang dicipta untuk pengabstrakan (mengabaikan perbezaan) dan untuk mengambil kira spesifik. (keupayaan untuk mengetahui konfigurasi secara pemrograman).

Amaran tentang tanda ®, ™ dalam artikel

Komen saya menerangkan sebab pekerja syarikat harus menggunakan notis hak cipta dalam komunikasi awam. Dalam artikel ini saya terpaksa menggunakannya dengan kerap.

CPU

Sudah tentu, istilah tertua, paling kerap digunakan dan kontroversi ialah "pemproses".

DALAM dunia moden pemproses ialah apa yang kita beli dalam kotak Runcit yang cantik atau pakej OEM yang tidak begitu bagus. Entiti yang tidak boleh dibahagikan dimasukkan ke dalam soket pada papan induk. Walaupun tidak ada penyambung dan ia tidak boleh dikeluarkan, iaitu, jika ia dipateri dengan ketat, ia adalah satu cip.

Sistem mudah alih (telefon, tablet, komputer riba) dan kebanyakan desktop mempunyai satu pemproses. Stesen kerja dan pelayan kadangkala mempunyai dua atau lebih pemproses pada satu papan induk.

Sokongan berbilang unit pemprosesan pusat dalam satu sistem memerlukan banyak perubahan dalam reka bentuknya. Sekurang-kurangnya, adalah perlu untuk memastikan sambungan fizikal mereka (menyediakan beberapa soket pada papan induk), menyelesaikan isu pengenalan pemproses (lihat kemudian dalam artikel ini, serta nota saya sebelum ini), penyelarasan akses memori dan penghantaran gangguan ( pengawal gangguan mesti dapat menghalakan gangguan untuk beberapa pemproses) dan, sudah tentu, sokongan daripada sistem pengendalian. Malangnya, saya tidak dapat mencari sebutan dokumentari mengenai penciptaan sistem berbilang pemproses pertama pada pemproses Intel, tetapi Wikipedia mendakwa bahawa Sistem Komputer Sequent telah membekalkannya pada tahun 1987, menggunakan pemproses Intel 80386 Sokongan untuk berbilang cip dalam satu sistem semakin meluas , bermula dengan Intel® Pentium.

Sekiranya terdapat beberapa pemproses, maka setiap daripada mereka mempunyai penyambung sendiri di papan. Setiap daripada mereka mempunyai salinan bebas lengkap semua sumber, seperti daftar, peranti pelaksanaan, cache. Mereka berkongsi memori yang sama - RAM. Memori boleh disambungkan kepada mereka dalam pelbagai cara dan bukan remeh, tetapi ini cerita lain, yang berada di luar skop artikel ini. Perkara penting ialah dalam apa jua keadaan, ilusi memori kongsi homogen yang boleh diakses daripada semua pemproses yang termasuk dalam sistem harus dicipta untuk program boleh laku.

Bersedia untuk berlepas! Papan Desktop Intel® D5400XS

teras

Dari segi sejarah, berbilang teras dalam Intel IA-32 muncul lebih lewat daripada Intel® HyperThreading, tetapi dalam hierarki logik ia datang seterusnya.

Nampaknya jika sistem mempunyai lebih banyak pemproses, maka prestasinya lebih tinggi (pada tugas yang boleh menggunakan semua sumber). Walau bagaimanapun, jika kos komunikasi antara mereka terlalu tinggi, maka semua keuntungan daripada keselarian dibunuh oleh kelewatan yang lama untuk pemindahan data biasa. Inilah yang diperhatikan dalam sistem berbilang pemproses - secara fizikal dan logik mereka sangat jauh antara satu sama lain. Untuk komunikasi berkesan Dalam keadaan sedemikian, adalah perlu untuk menghasilkan bas khusus, seperti Intel® QuickPath Interconnect. Penggunaan tenaga, saiz dan harga penyelesaian akhir, tentu saja, tidak dikurangkan oleh semua ini. Harus datang untuk menyelamatkan integrasi tinggi komponen - litar yang melaksanakan bahagian program selari, anda perlu menyeretnya lebih dekat antara satu sama lain, sebaik-baiknya pada satu kristal. Dalam erti kata lain, satu pemproses harus mengatur beberapa teras, sama antara satu sama lain dalam segala hal, tetapi bekerja secara bebas.

Pemproses IA-32 berbilang teras pertama daripada Intel telah diperkenalkan pada tahun 2005. Sejak itu, purata bilangan teras dalam pelayan, desktop dan sekarang platform mudah alih sedang berkembang dengan mantap.

Berbeza dengan keduanya pemproses teras tunggal Dalam sistem yang sama, hanya berkongsi memori, kedua-dua teras juga boleh berkongsi cache dan sumber lain yang bertanggungjawab untuk berinteraksi dengan memori. Selalunya, cache tahap pertama kekal peribadi (setiap teras mempunyainya sendiri), manakala tahap kedua dan ketiga boleh sama ada dikongsi atau berasingan. Organisasi sistem ini membolehkan anda mengurangkan kelewatan penghantaran data antara teras bersebelahan, terutamanya jika mereka sedang menjalankan tugas biasa.

Mikrograf pemproses Intel empat teras dengan nama kod Nehalem. Nukleus individu diserlahkan, cache kongsi tahap ketiga, serta pautan QPI kepada pemproses lain dan pengawal memori biasa.

Hyperthread

Sehingga kira-kira 2002, satu-satunya cara untuk mendapatkan sistem IA-32 yang mampu menjalankan dua atau lebih program secara selari adalah dengan menggunakan sistem multipemproses. Intel® Pentium® 4 serta barisan Xeon yang diberi nama kod Foster (Netburst) diperkenalkan Teknologi baru- hyperthreads atau hyperthreads, - Intel® HyperThreading (selepas ini HT).

Tidak ada yang baru di bawah matahari. HT ialah kes istimewa apa dalam kesusasteraan dipanggil multithreading serentak (SMT). Tidak seperti teras "sebenar", yang merupakan salinan lengkap dan bebas, dalam kes HT, hanya sebahagian daripada nod dalaman, yang bertanggungjawab terutamanya untuk menyimpan keadaan seni bina - daftar, diduplikasi dalam satu pemproses. Nod eksekutif yang bertanggungjawab untuk mengatur dan memproses data kekal tunggal, dan pada bila-bila masa digunakan oleh paling banyak satu daripada benang. Seperti teras, hyperthread berkongsi cache, tetapi dari tahap mana bergantung pada sistem tertentu.

Saya tidak akan cuba menerangkan semua kebaikan dan keburukan reka bentuk SMT secara umum dan reka bentuk HT khususnya. Pembaca yang berminat boleh menemui perbincangan terperinci tentang teknologi dalam banyak sumber, dan, sudah tentu, di Wikipedia. Walau bagaimanapun, saya akan perhatikan perkara penting berikut, yang menerangkan sekatan semasa ke atas bilangan hyperthread dalam produk sebenar.

Sekatan benang

Dalam kes apakah kehadiran berbilang teras "tidak adil" dalam bentuk HT wajar? Jika satu utas aplikasi tidak dapat memuatkan semua nod pelaksanaan di dalam kernel, maka mereka boleh "dipinjamkan" ke utas lain. Ini adalah tipikal untuk aplikasi yang mempunyai kesesakan bukan dalam pengiraan, tetapi dalam akses data, iaitu, sering menjana cache miss dan perlu menunggu data dihantar dari memori. Pada masa ini, teras tanpa HT akan dipaksa untuk melahu. Kehadiran HT membolehkan anda menukar nod pelaksana bebas dengan cepat kepada keadaan seni bina yang lain (kerana ia diduakan) dan melaksanakan arahannya. Ini adalah kes khas teknik yang dipanggil penyembunyian kependaman, apabila satu operasi yang panjang, di mana sumber berguna terbiar, disembunyikan oleh pelaksanaan selari tugas lain. Jika aplikasi sudah mempunyai tahap penggunaan sumber kernel yang tinggi, kehadiran hyperthread tidak akan membenarkan pecutan - kernel "jujur" diperlukan di sini.

Senario biasa untuk aplikasi desktop dan pelayan yang direka bentuk untuk seni bina mesin tujuan umum mempunyai potensi untuk keselarian dilaksanakan menggunakan HT. Walau bagaimanapun, potensi ini cepat digunakan. Mungkin atas sebab ini, pada hampir semua pemproses IA-32 bilangan hyperthread perkakasan tidak melebihi dua. Dalam senario biasa, keuntungan daripada menggunakan tiga atau lebih hyperthread adalah kecil, tetapi kerugian dalam saiz cetakan, penggunaan kuasa dan kosnya adalah ketara.

Situasi berbeza diperhatikan dalam tugas biasa yang dilakukan pada pemecut video. Oleh itu, seni bina ini dicirikan oleh penggunaan teknologi SMT dengan bilangan benang yang lebih besar. Oleh kerana pemproses bersama Intel® Xeon Phi (diperkenalkan pada 2010) secara ideologi dan genealogi agak hampir dengan kad video, mereka mungkin mempunyai empat hyperthreading pada setiap teras - konfigurasi unik untuk IA-32.

Pemproses logik

Daripada tiga "peringkat" selari (pemproses, teras, hyperthreads) yang diterangkan, sesetengah atau malah semua mungkin tiada dalam sistem tertentu. Ini dipengaruhi Tetapan BIOS(berbilang teras dan berbilang benang dilumpuhkan secara berasingan), ciri seni bina mikro (contohnya, HT tidak hadir dalam Intel® Core™ Duo, tetapi dikembalikan dengan keluaran Nehalem) dan peristiwa sistem (pelayan berbilang pemproses boleh mematikan pemproses yang gagal jika kesalahan dikesan dan terus "terbang" pada yang selebihnya). Bagaimanakah zoo berbilang peringkat konkurensi ini boleh dilihat oleh sistem pengendalian dan, akhirnya, kepada aplikasi aplikasi?

Selanjutnya, untuk kemudahan, kami menyatakan bilangan pemproses, teras dan benang dalam sistem tertentu sebanyak tiga ( x, y, z), Di mana x ialah bilangan pemproses, y- bilangan teras dalam setiap pemproses, dan z- bilangan hyperthread dalam setiap teras. Mulai sekarang saya akan memanggil mereka bertiga topologi- istilah mapan yang mempunyai sedikit kaitan dengan cabang matematik. Kerja hlm = xyz mentakrifkan bilangan entiti yang dipanggil pemproses logik sistem. Ia mentakrifkan jumlah bilangan konteks proses aplikasi bebas pada sistem memori yang dikongsi, dilaksanakan secara selari, yang sistem operasi terpaksa mengambil kira. Saya katakan "terpaksa" kerana ia tidak dapat mengawal perintah pelaksanaan dua proses pada pemproses logik yang berbeza. Ini juga terpakai kepada hyperthread: walaupun ia dijalankan "berurutan" pada teras yang sama, susunan khusus ditentukan oleh perkakasan dan tidak boleh diperhatikan atau dikawal oleh program.

Selalunya, sistem pengendalian menyembunyikan daripada aplikasi akhir ciri-ciri topologi fizikal sistem di mana ia dijalankan. Sebagai contoh, tiga topologi berikut: (2, 1, 1), (1, 2, 1) dan (1, 1, 2) - OS akan mewakilinya sebagai dua pemproses logik, walaupun yang pertama mempunyai dua pemproses, yang kedua mempunyai dua teras, dan yang ketiga hanya mempunyai dua utas.

Windows Pengurus Tugas menunjukkan 8 pemproses logik; tetapi berapa banyak ia dalam pemproses, teras dan hyperthread?

Bahagian atas Linux menunjukkan 4 pemproses logik.

Ini agak mudah untuk pencipta aplikasi - mereka tidak perlu berurusan dengan ciri perkakasan yang selalunya tidak penting bagi mereka.

Takrif perisian topologi

Sudah tentu, mengabstraksikan topologi ke dalam satu bilangan pemproses logik dalam beberapa kes mewujudkan alasan yang mencukupi untuk kekeliruan dan salah faham (dalam pertikaian Internet yang hangat). Aplikasi pengkomputeran yang ingin memerah prestasi maksimum daripada perkakasan memerlukan kawalan terperinci ke atas tempat benang mereka akan diletakkan: lebih dekat antara satu sama lain pada hyperthread bersebelahan atau, sebaliknya, lebih jauh pada pemproses yang berbeza. Kelajuan komunikasi antara pemproses logik dalam teras atau pemproses yang sama jauh lebih tinggi daripada kelajuan pemindahan data antara pemproses. Kemungkinan heterogeniti dalam organisasi memori kerja juga merumitkan gambar.

Maklumat tentang topologi sistem secara keseluruhan, serta kedudukan setiap pemproses logik dalam IA-32, tersedia menggunakan arahan CPUID. Sejak kemunculan sistem berbilang pemproses yang pertama, skema pengenalan pemproses logik telah diperluaskan beberapa kali. Sehingga kini, sebahagian daripadanya terkandung dalam helaian 1, 4 dan 11 CPUID. Helaian yang mana untuk dilihat boleh ditentukan daripada carta alir berikut yang diambil daripada artikel:

Saya tidak akan membosankan anda di sini dengan semua butiran bahagian individu algoritma ini. Jika ada minat, bahagian seterusnya artikel ini boleh dikhaskan untuk ini. Saya akan merujuk pembaca yang berminat, yang meneliti isu ini dengan seberapa terperinci yang mungkin. Di sini saya akan menerangkan secara ringkas apa itu APIC dan bagaimana ia berkaitan dengan topologi. Seterusnya kita akan melihat bekerja dengan helaian 0xB (sebelas in perpuluhan), yang dihidupkan pada masa ini ialah perkataan terakhir dalam "pembinaan apico".

ID APIC

APIC tempatan (pengawal gangguan boleh atur cara lanjutan) ialah peranti (kini sebahagian daripada pemproses) yang bertanggungjawab untuk mengendalikan gangguan yang datang kepada pemproses logik tertentu. Setiap pemproses logik mempunyai APIC sendiri. Dan setiap daripada mereka dalam sistem mesti mempunyai nilai ID APIC yang unik. Nombor ini digunakan oleh pengawal sampukan untuk menangani semasa menghantar mesej, dan oleh orang lain (contohnya, sistem pengendalian) untuk mengenal pasti pemproses logik. Spesifikasi untuk pengawal gangguan ini telah berkembang daripada Intel 8259 PIC melalui Dwi PIC, APIC dan xAPIC kepada x2APIC.

Pada masa ini, lebar nombor yang disimpan dalam ID APIC telah mencapai 32 bit penuh, walaupun pada masa lalu ia terhad kepada 16, dan lebih awal - hanya 8 bit. Hari ini, tinggalan zaman dahulu bertaburan di seluruh CPUID, tetapi CPUID.0xB.EDX mengembalikan semua 32 bit ID APIC. Pada setiap pemproses logik yang melaksanakan arahan CPUID secara bebas, nilai yang berbeza akan dikembalikan.

Menjelaskan hubungan kekeluargaan

Nilai APIC ID itu sendiri tidak memberitahu anda apa-apa tentang topologi. Untuk mengetahui dua pemproses logik yang terletak di dalam satu pemproses fizikal (iaitu, ia adalah hyperthreads "bersaudara"), yang mana dua berada di dalam pemproses yang sama, dan yang mana pemproses yang sama sekali berbeza, anda perlu membandingkan nilai APIC ID mereka. Bergantung pada tahap hubungan, beberapa bit mereka akan bertepatan. Maklumat ini terkandung dalam subsenarai CPUID.0xB, yang dikodkan dalam ECX. Setiap daripada mereka menerangkan kedudukan medan bit salah satu peringkat topologi dalam EAX (lebih tepat lagi, bilangan bit yang perlu dianjakkan ke kanan dalam ID APIC untuk mengalih keluar peringkat yang lebih rendah topologi), serta jenis lapisan ini - hyperthread, teras atau pemproses - dalam ECX.

Pemproses logik yang terletak di dalam teras yang sama akan mempunyai semua bit ID APIC yang sama, kecuali yang dimiliki oleh medan SMT. Untuk pemproses logik yang terletak dalam pemproses yang sama, semua bit kecuali medan Teras dan SMT. Memandangkan bilangan subhelaian untuk CPUID.0xB mungkin meningkat, skim ini akan membolehkan kami menyokong penerangan topologi dengan bilangan tahap yang lebih besar, jika keperluan timbul pada masa hadapan. Selain itu, adalah mungkin untuk memperkenalkan tahap pertengahan antara yang sedia ada.

Akibat penting daripada organisasi skim ini ialah mungkin terdapat "lubang" dalam set semua ID APIC semua pemproses logik dalam sistem, i.e. mereka tidak akan pergi secara berurutan. Sebagai contoh, dalam pemproses berbilang teras dengan HT dimatikan, semua ID APIC mungkin menjadi genap, kerana bit paling tidak ketara yang bertanggungjawab untuk pengekodan nombor hyperthread akan sentiasa menjadi sifar.

Saya perhatikan bahawa CPUID.0xB bukanlah satu-satunya sumber maklumat tentang pemproses logik yang tersedia untuk sistem pengendalian. Senarai semua pemproses yang tersedia untuknya, bersama-sama dengan nilai APIC ID mereka, dikodkan dalam jadual MADT ACPI.

Sistem pengendalian dan topologi

Sistem pengendalian menyediakan maklumat tentang topologi pemproses logik kepada aplikasi menggunakan antara muka mereka sendiri.

DALAM maklumat Linux Maklumat topologi terkandung dalam pseudofile /proc/cpuinfo serta dalam output arahan dmidecode. Dalam contoh di bawah, saya menapis kandungan cpuinfo pada beberapa sistem empat teras tanpa HT, meninggalkan hanya entri yang berkaitan dengan topologi:

Teks tersembunyi

ggg@shadowbox:~$ cat /proc/cpuinfo |grep "pemproses\|fizikal\ id\|adik-beradik\|teras\|teras\|apicid" pemproses: 0 id fizikal: 0 adik-beradik: 4 id teras: 0 teras cpu: 2 apicid: 0 apicid awal: 0 pemproses: 1 id fizikal: 0 adik beradik: 4 id teras: 0 teras cpu: 2 apicid: 1 apicid awal: 1 pemproses: 2 id fizikal: 0 adik beradik: 4 id teras: 1 teras cpu: 2 apicid: 2 apicid awal: 2 pemproses: 3 id fizikal: 0 adik beradik: 4 id teras: 1 teras cpu: 2 apicid: 3 apicid awal: 3

Pada FreeBSD, topologi dilaporkan melalui mekanisme sysctl dalam pembolehubah kern.sched.topology_spec sebagai XML:

Teks tersembunyi

pengguna@hos:~$ sysctl kern.sched.topology_spec kern.sched.topology_spec: 0, 1, 2, 3, 4, 5, 6, 7 0, 1, 2, 3, 4, 5, 6, 7 0, 1 kumpulan THREADkumpulan SMT 2, 3 kumpulan THREADkumpulan SMT 4, 5 kumpulan THREADkumpulan SMT 6, 7 kumpulan THREADkumpulan SMT

Dalam MS Windows 8, maklumat topologi boleh dilihat dalam Pengurus Tugas.

Ini ialah artikel keempat dalam siri "Memecah Had Windows", di mana saya bercakap tentang batasan yang wujud untuk sumber asas dalam Windows. Kali ini, saya akan berbincang dengan anda tentang had bilangan maksimum utas dan proses yang disokong oleh Windows. Di sini saya akan menerangkan secara ringkas perbezaan antara urutan dan proses, had tinjauan, dan kemudian kita akan bercakap tentang had proses. Pertama sekali, saya memutuskan untuk bercakap tentang had benang, kerana setiap proses aktif mempunyai, sekurang-kurangnya, satu utas (proses yang telah keluar tetapi rujukannya disimpan dalam pengendali yang disediakan oleh proses lain tidak mempunyai sebarang utas), jadi had proses bergantung secara langsung pada had utas asas.

Tidak seperti beberapa varian UNIX, kebanyakan sumber Windows tidak mempunyai had tetap yang dibina ke dalam sistem pengendalian pada masa binaan, sebaliknya terhad berdasarkan sumber asas yang tersedia untuk OS, yang saya bincangkan sebelum ini. Proses dan utas, sebagai contoh, memerlukan memori fizikal, memori maya dan memori kumpulan untuk diri mereka sendiri, jadi bilangan proses dan utas yang boleh dibuat pada sistem Windows tertentu akhirnya ditentukan oleh salah satu sumber ini, bergantung pada cara ini. proses atau utas telah dibuat dan had sumber asas mana yang akan dicapai dahulu. Oleh itu, saya mengesyorkan anda membaca artikel saya sebelum ini jika anda belum melakukannya, kerana seterusnya saya akan merujuk kepada konsep seperti ingatan simpanan, memori yang diperuntukkan dan had memori sistem, yang saya bincangkan dalam artikel saya sebelum ini :

Proses dan Benang
Proses Windows pada asasnya ialah bekas yang menyimpan kod arahan daripada fail boleh laku. Ia mewakili objek proses kernel, dan Windows menggunakan objek proses ini dan struktur data yang berkaitan untuk menyimpan dan mengekalkan maklumat tentang kod boleh laku aplikasi. Sebagai contoh, proses mempunyai ruang alamat maya di mana data peribadi dan awamnya disimpan dan ke dalamnya imej boleh laku dan yang berkaitan dengannya. DLL. Windows menggunakan alat diagnostik untuk merekodkan maklumat tentang penggunaan sumber proses untuk membantu menjejak dan melaksanakan permintaan dan merekodkan rujukan proses kepada objek sistem pengendalian dalam jadual pengendalian proses. Proses beroperasi dengan konteks keselamatan yang dipanggil token yang mengenal pasti akaun pengguna, kumpulan akaun dan keistimewaan yang diberikan kepada proses tersebut.

Proses termasuk satu atau lebih utas yang benar-benar melaksanakan kod dalam proses (secara teknikal, ia bukan proses yang dijalankan, tetapi utas) dan diwakili dalam sistem sebagai objek utas kernel. Terdapat beberapa sebab mengapa aplikasi mencipta utas sebagai tambahan kepada utas permulaan asalnya: 1) proses dengan antara muka pengguna lazimnya mencipta utas untuk melakukan kerja mereka sambil memastikan utas utama responsif kepada arahan input pengguna dan pengurusan tetingkap; 2) Aplikasi yang ingin menggunakan berbilang pemproses untuk menskalakan prestasi, atau yang ingin terus berjalan semasa utas terhenti menunggu I/O disegerakkan, cipta utas untuk memanfaatkan multithreading.

Sekatan benang
Selain maklumat asas tentang utas, termasuk keadaan daftar CPU, keutamaan utas dan maklumat tentang penggunaan sumber utas, setiap utas mempunyai bahagian ruang alamat proses yang diperuntukkan, dipanggil tindanan, yang boleh digunakan oleh utas sebagai ingatan kerja semasa pelaksanaan kod program, untuk menghantar parameter fungsi, menyimpan pembolehubah tempatan dan alamat hasil fungsi. Oleh itu, untuk mengelakkan pembaziran memori maya sistem, hanya sebahagian daripada timbunan diperuntukkan pada mulanya, atau sebahagian daripadanya dipindahkan ke benang, dan selebihnya hanya disimpan. Apabila timbunan memori berkembang dalam susunan menurun, sistem meletakkan apa yang dipanggil "halaman pengawal" memori di luar bahagian timbunan yang diperuntukkan, yang memastikan bahawa memori tambahan (dipanggil pengembangan tindanan) diperuntukkan secara automatik apabila ia diperlukan. Ilustrasi berikut menunjukkan cara kawasan tindanan yang diperuntukkan menjadi lebih dalam dan cara halaman pengawal bergerak apabila tindanan berkembang dalam ruang alamat 32-bit:

Struktur boleh laku Mudah Alih (PE) bagi imej boleh laku menentukan jumlah ruang alamat yang dikhaskan dan pada mulanya diperuntukkan kepada timbunan benang. Secara lalai, penyambung menyimpan 1MB dan memperuntukkan satu halaman (4KB), tetapi pembangun boleh menukar nilai ini sama ada dengan menukar nilai PE apabila mereka berkomunikasi dengan program mereka atau dengan memanggil fungsi CreateTread pada urutan yang berasingan. Anda boleh menggunakan utiliti seperti Dumpbin, yang disertakan dengan Visual Studio, untuk melihat tetapan program boleh laku. Berikut ialah hasil menjalankan Dumpbin dengan pilihan /headers pada boleh laku yang dijana oleh projek Visual Studio baharu:

Menukar nombor daripada sistem heksadesimal kalkulus, anda boleh melihat bahawa saiz rizab tindanan ialah 1MB dan kawasan memori yang diperuntukkan ialah 4KB; menggunakan utiliti baharu daripada Sysinternals yang dipanggil MMap, anda boleh melampirkan pada proses ini dan melihat ruang alamatnya, dan dengan itu melihat halaman memori tindanan yang diperuntukkan pada asalnya, halaman pengawal dan memori tindanan simpanan yang lain:

Oleh kerana setiap utas menggunakan sebahagian daripada ruang alamat proses, proses mempunyai had asas pada bilangan utas yang boleh mereka cipta, sama dengan saiz ruang alamat mereka dibahagikan dengan saiz tindanan benang.

Had aliran 32-bit
Walaupun proses tidak mempunyai kod atau data sama sekali dan keseluruhan ruang alamat boleh digunakan untuk tindanan, proses 32-bit dengan ruang alamat lalai sebanyak 2 bait boleh mencipta maksimum 2048 utas. Berikut ialah keputusan Testlimit yang dijalankan pada Windows 32-bit dengan pilihan -t (penciptaan benang), mengesahkan kehadiran pengehadan ini:

Sekali lagi, memandangkan beberapa ruang alamat telah digunakan untuk kod dan ingatan timbunan awal, tidak semua 2GB tersedia untuk susunan benang, jadi jumlah bilangan utas yang dicipta tidak dapat mencapai had teori 2048 utas.

Saya cuba menjalankan Testlimit dengan pilihan tambahan, yang memberikan aplikasi ruang alamat lanjutan, dengan harapan jika ia diberikan lebih daripada 2GB ruang alamat (contohnya, pada sistem 32-bit, ini dicapai dengan menjalankan aplikasi dengan pilihan /3GB atau /USERVA untuk Boot. ini, atau pilihan BCD yang setara pada Vista dan kemudian increaseuserva), ia akan menggunakannya. Proses 32-bit diperuntukkan 4GB ruang alamat apabila dijalankan pada Windows 64-bit, jadi berapa banyak utas boleh dibuat oleh Testlimit 32-bit yang berjalan pada Windows 64-bit? Berdasarkan perkara yang telah kita bincangkan, jawapannya mestilah 4096 (4GB dibahagikan dengan 1MB), tetapi dalam amalan, bilangan ini jauh lebih rendah. Berikut ialah Had Ujian 32-bit yang dijalankan pada Windows XP 64-bit:

Sebab percanggahan ini terletak pada hakikat bahawa apabila anda menjalankan aplikasi 32-bit pada Windows 64-bit, ia sebenarnya adalah proses 64-bit yang melaksanakan kod 64-bit bagi pihak benang 32-bit, dan oleh itu mempunyai per -kawasan ingatan benang dikhaskan untuk susunan benang 64-bit dan 32-bit. Untuk tindanan 64-bit, 256KB dikhaskan (pengecualian ialah OS yang dikeluarkan sebelum Vista, di mana saiz tindanan awal bagi benang 64-bit ialah 1MB). Memandangkan setiap benang 32-bit bermula dalam mod 64-bit dan saiz tindanan yang diperuntukkan semasa permulaan adalah lebih besar daripada saiz halaman, dalam kebanyakan kes anda akan melihat bahawa susunan benang 64-bit diperuntukkan sekurang-kurangnya 16Kb. Berikut ialah contoh tindanan 64-bit dan 32-bit strim 32-bit (tindanan 32-bit dilabelkan "Wow64"):

Testlimit 32-bit dapat mencipta 3204 thread pada Windows 64-bit, yang dijelaskan oleh fakta bahawa setiap thread menggunakan 1MB + 256KB ruang alamat untuk tindanan (sekali lagi, pengecualian adalah Versi Windows ke Vista, di mana 1MB+ 1MB digunakan). Walau bagaimanapun, saya mendapat hasil yang berbeza apabila menjalankan Testlimit 32-bit pada Windows 7 64-bit:

Perbezaan antara keputusan pada Windows XP dan Windows 7 adalah disebabkan oleh sifat rawak skema peruntukan ruang alamat Windows Vista, Address Space Layout Randomization (ASLR), yang membawa kepada beberapa pemecahan. Rawak pemuatan DLL, tindanan benang dan peletakan ingatan dinamik, membantu meningkatkan perlindungan terhadap perisian hasad. Seperti yang anda boleh lihat dalam petikan program VMMap berikut, dalam sistem ujian Masih terdapat 357MB ruang alamat yang tersedia, tetapi blok percuma terbesar ialah 128KB, iaitu kurang daripada 1MB yang diperlukan untuk tindanan 32-bit:

Seperti yang saya nyatakan, pembangun boleh mengatasi saiz rizab tindanan lalai. Satu daripada sebab yang mungkin Ini boleh dilakukan untuk mengelakkan pembaziran ruang alamat apabila diketahui terlebih dahulu bahawa susunan benang akan sentiasa menggunakan kurang daripada 1MB lalai. Imej Testlimit PE menggunakan saiz rizab tindanan sebanyak 64KB secara lalai, dan apabila anda menentukan pilihan -n bersama-sama dengan pilihan -t, Testlimit mencipta benang dengan saiz tindanan 64KB. Berikut ialah hasil menjalankan utiliti ini pada sistem dengan Windows XP 32-bit dan 256MB RAM (saya secara khusus menjalankan ujian ini pada sistem lemah, untuk menekankan had ini):

Perlu diingatkan di sini bahawa ralat lain berlaku, yang bermaksud bahawa dalam keadaan ini puncanya bukan ruang alamat. Malah, tindanan 64Kb harus menyediakan kira-kira 32,000 utas (2Gb/64Kb = 32,768). Jadi apakah had yang muncul dalam kes ini? Jika anda melihat calon yang mungkin, termasuk memori yang diperuntukkan dan kumpulan, mereka tidak memberikan sebarang petunjuk dalam mencari jawapan kepada soalan ini, kerana semua nilai ini berada di bawah hadnya:

Kita boleh dapatkan jawapannya di maklumat tambahan tentang memori dalam penyahpepijat kernel, yang akan memberitahu kami had yang diperlukan yang dikaitkan dengan memori pemastautin yang tersedia, yang jumlah keseluruhannya telah habis:

Memori pemastautin yang tersedia ialah memori fizikal yang diperuntukkan untuk data atau kod yang mesti berada dalam RAM. Saiz kumpulan bukan halaman dan pemacu bukan halaman dikira secara bebas, seperti, sebagai contoh, memori yang disimpan dalam RAM untuk operasi I/O. Setiap benang mempunyai kedua-dua tindanan mod pengguna, seperti yang telah saya bincangkan, tetapi mereka juga mempunyai tindanan mod istimewa (mod kernel), yang digunakan apabila benang beroperasi dalam mod kernel, seperti melaksanakan panggilan sistem. Apabila benang aktif, tindanan kernelnya disematkan dalam memori supaya benang boleh melaksanakan kod dalam kernel yang mana halaman yang diperlukan mungkin tidak hilang.

Tindanan kernel asas mengambil 12Kb pada Windows 32-bit dan 24Kb pada Windows 64-bit. Urutan 14225 memerlukan kira-kira 170MB memori pemastautin, iaitu jumlah memori percuma pada sistem ini dengan Testlimit dilumpuhkan:

Sebaik sahaja had memori sistem yang tersedia dicapai, banyak operasi asas mula gagal dengan kesilapan. Sebagai contoh, berikut ialah ralat yang saya dapat apabila saya mengklik dua kali pada pintasan internet Explorer terdapat pada desktop:

Seperti yang dijangka, berjalan pada Windows 64-bit dengan 256MB RAM, Testlimit dapat mencipta 6,600 utas - kira-kira separuh daripada banyak utas yang boleh dibuat pada Windows 32-bit dengan 256MB RAM - sebelum kehabisan memori yang tersedia:

Sebab saya sebelum ini menggunakan istilah tindanan kernel "asas" adalah bahawa benang yang melakukan grafik dan fungsi windowing mendapat tindanan "besar" apabila ia membuat panggilan pertama, yang sama dengan (atau lebih besar daripada) 20Kb setiap 32-bit Windows dan 48Kb pada Windows 64-bit. Utas testlimit tidak memanggil mana-mana API sedemikian, jadi ia mempunyai susunan inti asas.
Had aliran 64-bit

Seperti benang 32-bit, benang 64-bit mempunyai rizab tindanan 1MB secara lalai, tetapi benang 64-bit mempunyai lebih banyak ruang alamat pengguna (8TB), jadi ia tidak sepatutnya menjadi masalah apabila ia datang untuk mencipta nombor yang besar daripada benang. Namun jelas bahawa ingatan yang tersedia untuk penduduk masih menjadi pengehad yang berpotensi. Versi 64-bit Testlimit (Testlimit64.exe) dapat mencipta, dengan dan tanpa pilihan -n, kira-kira 6600 utas pada sistem dengan Windows XP 64-bit dan 256MB RAM, sama seperti versi 32-bit dicipta, kerana had telah dicapai memori tersedia pemastautin. Walau bagaimanapun, pada sistem dengan 2GB RAM, Testlimit64 hanya dapat mencipta 55,000 utas, yang jauh lebih kecil daripada bilangan utas yang boleh dibuat oleh utiliti ini jika pengehadannya ialah memori tersedia pemastautin (2GB/24KB = 89,000):

Dalam kes ini, puncanya ialah timbunan awal benang yang diperuntukkan, yang menyebabkan sistem kehabisan ingatan maya dan ralat muncul kerana kapasiti fail paging tidak mencukupi. Sebaik sahaja jumlah memori yang diperuntukkan mencapai saiz RAM, kadar penciptaan benang baharu berkurangan dengan ketara kerana sistem mula "tergelincir", susunan benang yang dibuat sebelum ini mula dihalakan ke fail halaman untuk memberi ruang kepada susunan benang baharu, dan fail halaman perlu berkembang. Dengan pilihan -n didayakan, hasilnya adalah sama, kerana jumlah awal memori tindanan yang diperuntukkan kekal sama.

Had Proses
Bilangan proses yang disokong oleh Windows jelas sepatutnya kurang daripada bilangan utas, kerana setiap proses mempunyai satu utas dan proses itu sendiri menyebabkan penggunaan sumber tambahan. Had Ujian 32-bit berjalan pada sistem dengan Windows XP 64-bit dan memori sistem 2GB menghasilkan kira-kira 8400 proses:

Jika anda melihat hasil penyahpepijat kernel, menjadi jelas bahawa dalam kes ini had memori tersedia pemastautin dicapai:

Jika suatu proses menggunakan memori tersedia pemastautin untuk menampung hanya timbunan utas mod istimewa, Testlimit akan dapat mencipta lebih daripada 8400 utas pada sistem 2GB. Jumlah memori pemastautin yang tersedia pada sistem ini tanpa Testlimit dijalankan ialah 1.9GB:

Dengan membahagikan jumlah memori pemastautin yang digunakan oleh Testlimit (1.9 GB) dengan bilangan proses yang dihasilkannya, kami mendapati bahawa setiap proses mempunyai 230 KB memori pemastautin. Memandangkan timbunan kernel 64-bit mengambil masa 24 KB, kami akhirnya kehilangan kira-kira 206 KB setiap proses. Di manakah baki memori penduduk yang digunakan? Apabila proses dibuat, Windows menyimpan memori fizikal yang mencukupi untuk menyediakan set halaman kerja minimum. Ini dilakukan untuk memastikan bahawa proses, dalam apa jua keadaan, akan mempunyai memori fizikal yang mencukupi untuk digunakan untuk menyimpan jumlah data yang diperlukan untuk menyediakan set halaman kerja minimum. Secara lalai, saiz set halaman yang berfungsi selalunya ialah 200KB, yang boleh disahkan dengan mudah dengan menambahkan lajur Set Kerja Minimum dalam tetingkap Process Explorer:

Baki 6Kb ialah memori boleh diakses pemastautin, diperuntukkan untuk memori tidak boleh halaman tambahan (daripada memori tidak boleh halaman bahasa Inggeris), di mana proses itu sendiri disimpan. Proses pada Windows 32-bit menggunakan memori pemastautin yang kurang sedikit kerana susunan keistimewaan benangnya lebih kecil.

Seperti susunan benang mod pengguna, proses boleh mengatasi saiz halaman set kerja lalai mereka dengan menggunakan fungsi SetProcessWorkingSetSize. Testlimit menyokong pilihan -n, yang, dalam kombinasi dengan pilihan -p, membolehkan anda menetapkan saiz minimum yang mungkin bagi set halaman berfungsi kepada 80Kb untuk proses anak proses Testlimit utama. Oleh kerana proses kanak-kanak memerlukan masa untuk mengurangkan set halaman kerja mereka, Testlimit, selepas ia tidak lagi dapat menghasilkan proses, berhenti seketika dan cuba untuk terus berjalan, memberikan proses anaknya peluang untuk melaksanakan. Testlimit, dilancarkan dengan parameter -n pada sistem dengan Windows 7 dan 4GB RAM, mempunyai had yang berbeza daripada had memori yang tersedia pemastautin - had pada memori sistem yang diperuntukkan:

Dalam tangkapan skrin di bawah, anda boleh melihat bahawa penyahpepijat kernel melaporkan bukan sahaja bahawa had memori sistem yang diperuntukkan telah dicapai, tetapi juga bahawa, selepas mencapai had ini, beribu-ribu ralat peruntukan memori, kedua-dua maya dan memori, telah berlaku kumpulan halaman (had memori sistem yang diperuntukkan sebenarnya telah dicapai beberapa kali, kerana apabila ralat berlaku disebabkan kekurangan kapasiti fail halaman, volum yang sama ini meningkat, menolak had ini):

Sebelum menjalankan Testlimit, purata peruntukan memori ialah kira-kira 1.5GB, jadi benang mengambil kira-kira 8GB memori yang diperuntukkan. Oleh itu, setiap proses menggunakan kira-kira 8 GB/6600 atau 1.2 MB. Keluaran arahan debugger!vm kernel, yang menunjukkan pengedaran ingatan sendiri(dari ingatan peribadi Inggeris) untuk setiap proses, mengesahkan ketepatan pengiraan ini:

Jumlah memori awal yang diperuntukkan kepada timbunan benang, yang diterangkan sebelum ini, mempunyai sedikit kesan ke atas permintaan peruntukan memori yang tinggal yang diperlukan untuk struktur data ruang alamat proses, entri jadual halaman, mengendalikan entri jadual, objek proses dan benang, dan datanya sendiri yang proses tercipta semasa pemulaannya.

Berapa banyak proses dan benang akan mencukupi?
Oleh itu, jawapan kepada soalan "berapa banyak benang yang Windows menyokong?" dan "berapa banyak proses yang boleh anda jalankan serentak pada Windows?" saling berkaitan. Selain daripada nuansa cara benang menentukan saiz tindanannya dan cara proses menentukan set halaman kerja minimum mereka, dua faktor utama yang menentukan jawapan kepada soalan ini pada mana-mana sistem tertentu ialah jumlah memori fizikal dan had peruntukan memori sistem. Walau apa pun, jika aplikasi mencipta rangkaian atau proses yang mencukupi untuk menghampiri had ini, maka pembangunnya harus mempertimbangkan semula reka bentuk aplikasi itu, kerana sentiasa ada cara yang berbeza untuk mencapai hasil yang sama dengan bilangan proses yang munasabah. Sebagai contoh, matlamat utama apabila menskalakan aplikasi adalah untuk memastikan bilangan utas yang sedang berjalan sama dengan bilangan CPU, dan satu cara untuk mencapainya ialah beralih daripada menggunakan I/O segerak kepada tak segerak menggunakan port penyiapan, yang sepatutnya membantu mengekalkan bilangan utas berjalan selaras dengan bilangan CPU.

Dalam artikel ini kita akan bercakap tentang topik seperti proses dan benang, deskriptor proses, mari kita bercakap tentang penyegerakan aliran dan mari kita sentuh kegemaran semua orang pengurus tugas windows.

Sepanjang kewujudan proses pelaksanaannya boleh diganggu dan diteruskan berkali-kali. Untuk menyambung semula pelaksanaan proses, adalah perlu untuk memulihkan keadaan persekitaran operasinya. Keadaan persekitaran operasi dipaparkan oleh keadaan daftar dan pembilang program, mod pengendalian pemproses, penunjuk untuk membuka fail, maklumat tentang operasi I/O yang belum selesai, kod ralat panggilan sistem yang dilakukan oleh proses ini, dsb. Maklumat ini dipanggil konteks proses.

Untuk membolehkan OS mengurus proses, ia mesti mempunyai semua maklumat yang diperlukan untuk ini. Untuk tujuan ini, setiap proses bermula pemegang proses.

Deskriptor – istimewa struktur maklumat, yang dimulakan untuk setiap proses (deskriptor tugas, blok kawalan tugas).

Secara umum, deskriptor mengandungi maklumat berikut:

1. ID Proses.
2. Jenis proses (atau kelas) yang mentakrifkan beberapa peraturan peruntukan sumber untuk penyelia.
3. Keutamaan proses.
4. Pembolehubah keadaan yang menentukan dalam keadaan apa proses itu (bersedia untuk dijalankan, berjalan, menunggu peranti I/O, dsb.)
5. Kawasan memori yang dilindungi (atau alamat zon sedemikian) di mana nilai semasa daftar pemproses disimpan jika proses terganggu tanpa menyelesaikan kerjanya. Maklumat ini dipanggil konteks tugas.
6. Maklumat tentang sumber yang dimiliki oleh proses dan/atau berhak untuk digunakan (penunjuk untuk membuka fail, maklumat tentang operasi I/O yang belum selesai, dsb.).
7. Tempat (atau alamatnya) untuk mengatur komunikasi dengan proses lain.
8. Parameter masa permulaan (titik dalam masa apabila proses harus diaktifkan dan kekerapan prosedur ini).
9. Sekiranya tiada sistem pengurusan fail, alamat tugas pada cakera dalam keadaan awalnya dan alamat pada cakera di mana ia dipunggah daripada RAM jika ia digantikan oleh yang lain.

Pemegang proses Berbanding dengan konteks, ia mengandungi lebih banyak maklumat operasi yang sepatutnya mudah diakses oleh subsistem perancangan proses. Konteks proses mengandungi maklumat yang kurang relevan dan digunakan oleh sistem pengendalian hanya selepas keputusan dibuat untuk menyambung semula proses yang terganggu.

Deskriptor, sebagai peraturan, ditempatkan secara kekal dalam RAM untuk mempercepatkan kerja penyelia, yang menyusunnya ke dalam senarai (baris gilir) dan memaparkan perubahan dalam keadaan proses dengan mengalihkan deskriptor yang sepadan dari satu senarai ke senarai yang lain.

Untuk setiap keadaan (kecuali untuk keadaan larian untuk sistem pemproses tunggal), OS mengekalkan senarai tugasan yang sepadan yang berada dalam keadaan itu. Walau bagaimanapun, boleh terdapat lebih daripada satu senarai untuk keadaan menunggu, tetapi kerana pelbagai jenis sumber boleh menyebabkan keadaan menunggu.

Sebagai contoh, mungkin terdapat banyak keadaan menunggu untuk operasi I/O selesai kerana terdapat peranti I/O dalam sistem.

Proses dan Benang

Untuk menyokong multiprogramming, OS mesti mentakrifkan dan mereka bentuk untuk dirinya sendiri unit kerja dalaman yang antara pemproses dan sumber komputer lain akan dibahagikan. Pada masa ini, kebanyakan sistem pengendalian mentakrifkan dua jenis unit kerja:

• Proses(unit kerja yang lebih besar).
• Aliran(benang atau benang) ialah unit kerja yang lebih kecil yang diperlukan oleh proses untuk diselesaikan.
• Apabila mereka bercakap tentang proses, maka mereka ingin ambil perhatian bahawa OS menyokong pengasingan mereka: setiap proses mempunyai ruang alamat mayanya sendiri, setiap proses diperuntukkan sumbernya sendiri - fail, tingkap, dll. Pengasingan sedemikian diperlukan untuk melindungi satu proses daripada yang lain, kerana mereka, berkongsi semua sumber sistem pengkomputeran, mereka bersaing antara satu sama lain.

Secara umum proses semata-mata tidak berkaitan antara satu sama lain dalam apa jua cara malah mungkin dimiliki oleh pengguna berbeza yang berkongsi perkara yang sama sistem komputer. Dalam erti kata lain, dalam kes proses, OS menganggapnya sama sekali tidak berkaitan dan bebas. Dalam kes ini, OS yang bertanggungjawab untuk persaingan antara proses untuk sumber.

Untuk meningkatkan kelajuan proses, adalah mungkin untuk menggunakan paralelisme dalaman dalam proses itu sendiri. proses.

Sebagai contoh, sesetengah operasi yang dilakukan oleh aplikasi mungkin memerlukan penggunaan CPU yang agak banyak untuk diselesaikan. Dalam kes ini, apabila bekerja secara interaktif dengan aplikasi, pengguna terpaksa menunggu masa yang lama untuk menyelesaikan operasi yang dipesan dan tidak boleh mengawal aplikasi sehingga operasi selesai hingga akhir. Situasi sedemikian berlaku agak kerap, contohnya, apabila memproses imej besar dalam editor grafik. Jika modul perisian, melakukan operasi yang begitu panjang, harus diformalkan sebagai "subproses" bebas ( aliran), yang akan dilaksanakan selari dengan "subproses" lain, maka pengguna mempunyai peluang untuk melakukan beberapa operasi secara serentak dalam satu aplikasi (proses).

Perbezaan berikut dapat dikenalpasti benang daripada proses:

• OS untuk benang tidak seharusnya mengatur mesin maya yang lengkap.
• Benang tidak mempunyai sumber sendiri, ia berkembang dalam ruang alamat maya yang sama, dan boleh menggunakan fail, peranti maya dan sumber lain yang sama seperti proses yang diberikan.
• Satu-satunya perkara yang perlu ada pada benang ialah sumber CPU. Pada sistem unipemproses, benang berkongsi masa pemproses antara satu sama lain dengan cara yang sama seperti proses biasa, tetapi pada sistem berbilang pemproses mereka boleh melaksanakan secara serentak jika mereka tidak menghadapi persaingan kerana akses kepada sumber lain.

Perkara utama yang memastikan multithreading, ialah keupayaan untuk melaksanakan beberapa jenis operasi secara selari dalam satu program aplikasi. Bagaimana ia dilaksanakan? penggunaan yang cekap sumber CPU, dan jumlah masa pelaksanaan tugas menjadi kurang.

Contohnya, jika pemproses meja atau pemproses perkataan direka bentuk dengan mengambil kira keupayaan berbilang benang, pengguna boleh meminta pengiraan semula lembaran kerja mereka atau gabungan berbilang dokumen dan pada masa yang sama terus mengisi jadual atau membuka dokumen seterusnya untuk diedit.

Pengurus Tugas WINDOWS

Pengurus Tugas memaparkan maklumat tentang program dan proses melaksanakan pada komputer. Anda juga boleh melihat metrik prestasi proses yang paling biasa digunakan di sana.

Pengurus Tugas berfungsi untuk memaparkan penunjuk utama prestasi komputer. Untuk menjalankan program, anda boleh melihat statusnya dan menamatkan program yang telah berhenti bertindak balas. Anda boleh melihat aktiviti menjalankan proses menggunakan sehingga 15 parameter, serta graf dan maklumat tentang penggunaan CPU dan memori.

Selain itu, jika anda disambungkan ke rangkaian, anda boleh melihat status rangkaian dan parameter prestasi. Jika berbilang pengguna disambungkan ke komputer anda, anda boleh melihat nama mereka, tugas yang mereka lakukan dan menghantar mesej kepada mereka.

Pada tab Proses memaparkan maklumat tentang proses yang berjalan pada komputer: maklumat tentang penggunaan CPU dan memori, pembilang proses dan beberapa parameter lain:

Pada tab Prestasi, maklumat tentang kaunter deskriptor dan benang, parameter memori dipaparkan:

Perlu masuk penyegerakan benang berlaku hanya dalam OS berbilang program dan dikaitkan dengan penggunaan bersama perkakasan dan sumber maklumat komputer. Penyegerakan adalah perlu untuk mengelakkan perlumbaan (lihat di bawah) dan kebuntuan apabila bertukar-tukar data antara benang, berkongsi data dan apabila mengakses pemproses dan peranti I/O.

Penyegerakan benang dan proses terdiri daripada menyelaraskan kelajuannya dengan menggantung aliran sehingga berlakunya peristiwa tertentu dan pengaktifannya seterusnya apabila kejadian ini berlaku.

Mengabaikan isu penyegerakan dalam sistem berbilang benang boleh menyebabkan keputusan yang salah tugasan atau pun ranap sistem.

Contoh . Tugas mengekalkan pangkalan data pelanggan untuk perusahaan tertentu.

Setiap pelanggan diberi kemasukan berasingan dalam pangkalan data yang mengandungi medan Pesanan dan Pembayaran. Program yang mengekalkan pangkalan data direka bentuk sebagai satu proses dengan beberapa utas, termasuk:

• Thread A, yang memasukkan maklumat tentang pesanan yang diterima daripada pelanggan ke dalam pangkalan data.
• Thread B, yang merekodkan dalam maklumat pangkalan data tentang pembayaran pelanggan untuk invois.

Kedua-dua utas ini berfungsi bersama pada fail pangkalan data biasa menggunakan jenis algoritma yang sama:

1. Baca rekod dengan pengecam yang diberikan daripada fail pangkalan data ke dalam penimbal pada klien.
2. Masukkan nilai baharu dalam medan Pesanan (untuk aliran A) atau pembayaran (untuk aliran B).
3. Kembalikan rekod yang diubah suai kepada fail pangkalan data.

Mari kita nyatakan langkah 1-3 untuk aliran A sebagai A1-A3, dan untuk aliran B sebagai B1-B3. Mari kita anggap bahawa pada satu ketika thread A mengemas kini medan Pesanan rekod tentang pelanggan N. Untuk melakukan ini, ia membaca rekod ini ke dalam penimbalnya (langkah A1), mengubah suai nilai medan Pesanan (langkah A2), tetapi tidak mempunyai masa untuk menambah rekod ke pangkalan data, kerana pelaksanaannya terganggu, sebagai contoh, disebabkan oleh tamat tempoh kepingan masa.

Katakan bahawa utas B juga perlu memasukkan maklumat pembayaran mengenai pelanggan yang sama N. Apabila giliran B tiba, ia berjaya membaca masukan ke dalam penimbalnya (langkah B1) dan mengemas kini medan Bayaran(langkah B2) dan kemudian menggugurkan. Ambil perhatian bahawa dalam penimbal aliran B terdapat rekod tentang klien N, di mana medan Pesanan mempunyai makna yang sama dan tidak berubah.

Satu konsep yang penting penyegerakan proses ialah konsep "bahagian kritikal" sesuatu program. Bahagian kritikal- Ini adalah bahagian program di mana data yang dikongsi diakses. Untuk menghapuskan kesan keadaan perlumbaan pada sumber, adalah perlu untuk memastikan bahawa pada bila-bila masa terdapat paling banyak satu proses dalam bahagian kritikal yang dikaitkan dengan sumber tersebut. Teknik ini dipanggil pengecualian bersama.

Cara paling mudah untuk menguatkuasakan pengecualian bersama ialah membenarkan proses di bahagian kritikal untuk melumpuhkan semua gangguan. Walau bagaimanapun, kaedah ini tidak sesuai, kerana adalah berbahaya untuk mempercayai kawalan sistem kepada proses pengguna; ia boleh menduduki pemproses untuk masa yang lama, dan jika proses ranap di kawasan kritikal, keseluruhan sistem akan ranap kerana gangguan tidak akan didayakan.

Cara lain ialah menggunakan pembolehubah menyekat. Setiap sumber yang dikongsi mempunyai pembolehubah binari yang dikaitkan dengannya yang mengambil nilai 1 jika sumber itu percuma (iaitu, tiada proses pada masa ini berada dalam bahagian kritikal yang dikaitkan dengan proses itu) dan nilai 0 jika sumber itu sibuk. Rajah di bawah menunjukkan serpihan algoritma proses yang menggunakan pembolehubah penyekat F(D) untuk melaksanakan pengecualian bersama akses kepada sumber kongsi D. Sebelum memasuki bahagian kritikal, proses menyemak sama ada sumber D adalah percuma Jika ia sibuk, maka semakan diulang secara kitaran jika ia bebas, maka nilai pembolehubah F(D) ditetapkan kepada 0, dan proses memasuki bahagian kritikal. Selepas proses menyelesaikan semua operasi dengan sumber D yang dikongsi, nilai pembolehubah F(D) sekali lagi ditetapkan kepada 1.

Jika semua proses ditulis menggunakan konvensyen di atas, maka pengecualian bersama dijamin. Perlu diingatkan bahawa operasi menyemak dan menetapkan pembolehubah penyekat mestilah tidak boleh dibahagikan. Ini dijelaskan seperti berikut. Katakan bahawa, hasil daripada menyemak pembolehubah, proses menentukan bahawa sumber itu percuma, tetapi selepas itu, tanpa mempunyai masa untuk menetapkan pembolehubah kepada 0, ia terganggu. Semasa ia digantung, proses lain telah menduduki sumber, memasuki bahagian kritikalnya, tetapi juga terganggu tanpa menyelesaikan kerja dengan sumber yang dikongsi. Apabila kawalan dikembalikan kepada proses pertama, ia, memandangkan sumber bebas, menetapkan tanda sibuk dan mula melaksanakan bahagian kritikalnya. Oleh itu, prinsip pengecualian bersama telah dilanggar, yang berpotensi membawa kepada akibat yang tidak diingini. Untuk mengelakkan situasi sedemikian, adalah dinasihatkan untuk mempunyai satu arahan "pemasangan semak" dalam sistem arahan mesin, atau untuk melaksanakan sistem bermaksud primitif perisian yang sesuai yang akan melumpuhkan gangguan sepanjang keseluruhan operasi pengesahan dan pemasangan.

Melaksanakan bahagian kritikal menggunakan pembolehubah menyekat mempunyai kelemahan yang ketara: semasa satu proses berada dalam bahagian kritikal, proses lain yang memerlukan sumber yang sama akan dilaksanakan aktiviti rutin dengan mengundi pembolehubah penyekat, membuang masa CPU. Untuk menghapuskan situasi sedemikian, aparat yang dipanggil acara boleh digunakan. Alat ini boleh digunakan untuk menyelesaikan bukan sahaja masalah pengecualian bersama, tetapi juga masalah penyegerakan proses yang lebih umum. Dalam sistem pengendalian yang berbeza, radas acara dilaksanakan dengan caranya sendiri, tetapi dalam apa jua keadaan, fungsi sistem untuk tujuan yang sama digunakan, yang secara konvensional dipanggil WAIT(x) dan POST(x), di mana x ialah pengecam beberapa peristiwa.

Jika sumber sibuk, maka proses itu tidak melakukan tinjauan kitaran, tetapi memanggil fungsi sistem WAIT(D), di sini D menandakan peristiwa sumber D dikeluarkan Fungsi WAIT(D) meletakkan proses aktif dalam WAITING nyatakan dan buat nota dalam deskriptornya bahawa proses sedang menunggu peristiwa D. Proses yang sedang menggunakan sumber D, selepas keluar dari bahagian kritikal, melaksanakan fungsi sistem POST(D), akibatnya sistem pengendalian mengimbas baris gilir proses menunggu dan meletakkan proses menunggu peristiwa D ke dalam keadaan SEDIA .

Cara umum untuk menyegerakkan proses telah dicadangkan oleh Dijkstra, yang memperkenalkan dua primitif baru. Dalam bentuk abstrak, primitif ini, dilambangkan P dan V, beroperasi pada pembolehubah integer bukan negatif yang dipanggil semaphore. Biarkan S menjadi semafor. Operasi ditakrifkan seperti berikut:

V(S): pembolehubah S meningkat sebanyak 1 dengan satu tindakan tidak boleh dibahagikan; ambil, kenaikan dan simpan tidak boleh diganggu dan S tidak diakses oleh proses lain semasa operasi ini sedang dijalankan.

P(S): Menurunkan S sebanyak 1 jika boleh. Jika S=0, maka adalah mustahil untuk mengurangkan S dan kekal dalam kawasan nilai integer bukan negatif, dalam hal ini proses memanggil operasi P menunggu sehingga penurunan ini menjadi mungkin. Berjaya menyemak dan mengurangkan juga merupakan operasi yang tidak boleh dibahagikan.

Dalam kes khas di mana semaphore S hanya boleh mengambil nilai 0 dan 1, ia bertukar menjadi pembolehubah menyekat. Operasi P mempunyai potensi untuk meletakkan proses yang melaksanakannya ke dalam keadaan menunggu, manakala operasi V mungkin, dalam keadaan tertentu, mengaktifkan proses lain yang digantung oleh operasi P.

Kebuntuan proses

Apabila mengatur pelaksanaan selari beberapa proses, salah satu fungsi utama OS ialah pengagihan sumber yang betul antara proses yang berjalan dan menyediakan proses dengan cara penyegerakan bersama dan pertukaran data.

Apabila melaksanakan proses secara selari, situasi mungkin timbul di mana dua atau lebih proses berada dalam keadaan tersekat pada setiap masa. Kes paling mudah ialah apabila setiap satu daripada dua proses sedang menunggu sumber yang diduduki oleh proses yang lain. Oleh kerana penantian ini, kedua-dua proses tidak dapat meneruskan pelaksanaan dan akhirnya melepaskan sumber yang diperlukan oleh proses lain. Kebuntuan ini dipanggil kebuntuan(kunci mati) Jalan mati, merangkul atau kebuntuan.

Dalam sistem multitasking, sesuatu proses dikatakan buntu jika ia menunggu sesuatu peristiwa yang tidak akan berlaku.

Situasi kebuntuan mesti dibezakan daripada beratur ringkas, walaupun kedua-duanya berlaku apabila sumber dikongsi dan kelihatan serupa: proses digantung dan menunggu sumber menjadi percuma. Walau bagaimanapun, baris gilir adalah perkara biasa dan merupakan tanda wujud penggunaan sumber yang tinggi apabila permintaan tiba secara rawak. Ia berlaku apabila sumber tidak tersedia pada masa ini, tetapi selepas beberapa lama ia dikeluarkan, dan proses meneruskan pelaksanaannya. Kebuntuan adalah keadaan yang agak tidak dapat diselesaikan.

Masalah kebuntuan termasuk tugas berikut:

1. mengelakkan kebuntuan.
2. pengiktirafan kebuntuan.
3. memulihkan sistem selepas kebuntuan.

Kebuntuan boleh dicegah pada peringkat penulisan program, iaitu program mesti ditulis sedemikian rupa sehingga kebuntuan tidak boleh berlaku di bawah sebarang nisbah kelajuan bersama proses. Jadi, jika dalam contoh sebelumnya proses A dan proses B meminta sumber dalam urutan yang sama, maka kebuntuan akan menjadi mustahil pada dasarnya. Pendekatan kedua untuk mencegah kebuntuan dipanggil dinamik dan melibatkan penggunaan peraturan tertentu apabila memperuntukkan sumber kepada proses, contohnya, sumber boleh diperuntukkan dalam urutan tertentu yang biasa kepada semua proses.

Dalam sesetengah kes, apabila kebuntuan berlaku di antara banyak proses menggunakan banyak sumber, mengiktiraf kebuntuan adalah tugas yang tidak remeh. Terdapat kaedah formal yang dilaksanakan perisian untuk mengenal pasti kebuntuan, berdasarkan mengekalkan jadual peruntukan sumber dan jadual pertanyaan untuk sumber yang diduduki. Analisis jadual ini membolehkan anda mengesan kebuntuan.

Sekiranya keadaan kebuntuan berlaku, maka tidak perlu mengalih keluar semua proses yang disekat daripada pelaksanaan. Anda boleh mengalih keluar hanya sebahagian daripada mereka, yang membebaskan sumber yang dijangkakan oleh proses lain, anda boleh mengembalikan beberapa proses ke kawasan swap, anda boleh "mengembalikan" beberapa proses ke pusat pemeriksaan yang dipanggil, yang menyimpan semua maklumat yang diperlukan untuk memulihkan program pelaksanaan daripada tempat ini. Pusat pemeriksaan diletakkan dalam program di tempat yang selepas itu kebuntuan mungkin berlaku.