Sumber daya apa yang dibagi di antara utas?

Baru-baru ini, saya telah ditanya pertanyaan dalam wawancara apa perbedaan antara proses dan utas. Sungguh, saya tidak tahu jawabannya. Saya berpikir sejenak dan memberikan jawaban yang sangat aneh.

Thread berbagi memori yang sama, proses tidak. Setelah menjawab ini, pewawancara memberi saya senyum jahat dan mengajukan pertanyaan berikut kepada saya:

P. Apakah Anda tahu segmen di mana suatu program dibagi?

Jawaban saya: ya (pikir itu mudah) Stack, Data, Code, Heap

Q. Jadi, beri tahu saya: segmen mana yang dibagikan thread?

Saya tidak bisa menjawab ini dan akhirnya mengatakan semuanya.

Tolong, bisakah ada yang menyajikan jawaban yang benar dan mengesankan untuk perbedaan antara proses dan utas?

Anda benar, tetapi utas membagikan semua segmen kecuali tumpukan. Utas memiliki susunan panggilan independen, namun memori di susunan utas lainnya masih dapat diakses dan secara teori Anda dapat menahan pointer ke memori dalam kerangka tumpukan lokal beberapa utas lainnya (meskipun Anda mungkin harus menemukan tempat yang lebih baik untuk meletakkan memori itu!).

Dari Wikipedia (saya pikir itu akan menjadi jawaban yang sangat bagus untuk pewawancara: P)

Utas berbeda dari proses sistem operasi multitasking tradisional dalam hal:

• proses biasanya independen, sementara utas ada sebagai himpunan bagian dari suatu proses
• proses membawa informasi keadaan yang cukup, sedangkan banyak utas dalam keadaan berbagi proses serta memori dan sumber daya lainnya
• proses memiliki ruang alamat yang terpisah, sedangkan utas berbagi ruang alamat mereka
• proses berinteraksi hanya melalui mekanisme komunikasi antar proses yang disediakan sistem.
• Pergantian konteks antar utas dalam proses yang sama biasanya lebih cepat daripada pergantian konteks antar proses.

Sesuatu yang benar-benar perlu ditunjukkan adalah bahwa sebenarnya ada dua aspek untuk pertanyaan ini - aspek teoritis dan aspek implementasi.

Pertama, mari kita lihat aspek teoretisnya. Anda perlu memahami apa proses secara konseptual untuk memahami perbedaan antara proses dan utas dan apa yang dibagikan di antara mereka.

Kami memiliki yang berikut dari bagian 2.2.2 Model Thread Klasik dalam Sistem Operasi Modern 3e oleh Tanenbaum:

Model proses didasarkan pada dua konsep independen: pengelompokan sumber daya dan eksekusi. Terkadang berguna untuk memisahkan mereka; Di sinilah utas masuk ....

Dia melanjutkan:

Salah satu cara memandang suatu proses adalah cara mengelompokkan sumber daya terkait. Suatu proses memiliki ruang alamat yang berisi teks dan data program, serta sumber daya lainnya. Sumber daya ini dapat mencakup file terbuka, proses anak, alarm yang tertunda, penangan sinyal, informasi akuntansi, dan banyak lagi. Dengan menyatukan mereka dalam bentuk proses, mereka dapat dikelola dengan lebih mudah. Konsep lain yang dimiliki suatu proses adalah utas eksekusi, biasanya disingkat menjadi hanya utas. Utas memiliki penghitung program yang melacak instruksi mana yang harus dijalankan selanjutnya. Ini memiliki register, yang menyimpan variabel kerja saat ini. Ini memiliki tumpukan, yang berisi riwayat eksekusi, dengan satu frame untuk setiap prosedur yang dipanggil tetapi belum kembali dari. Meskipun utas harus dijalankan dalam beberapa proses, utas dan prosesnya adalah konsep yang berbeda dan dapat diperlakukan secara terpisah. Proses digunakan untuk mengelompokkan sumber daya bersama; utas adalah entitas yang dijadwalkan untuk dieksekusi pada CPU.

Lebih jauh ke bawah ia menyediakan tabel berikut:

Per process items             | Per thread items
------------------------------|-----------------
Address space                 | Program counter
Global variables              | Registers
Open files                    | Stack
Child processes               | State
Pending alarms                |
Signals and signal handlers   |
Accounting information        |

Di atas adalah apa yang Anda butuhkan agar thread dapat berfungsi. Seperti yang telah ditunjukkan orang lain, hal-hal seperti segmen adalah detail implementasi tergantung OS.

Beri tahu pewawancara bahwa itu sepenuhnya tergantung pada implementasi OS.

Ambil Windows x86 misalnya. Hanya ada 2 segmen [1], Kode dan Data. Dan keduanya dipetakan ke seluruh ruang alamat 2GB (linier, pengguna). Basis = 0, Batas = 2GB. Mereka akan membuat satu tetapi x86 tidak memungkinkan segmen menjadi Baca / Tulis dan Jalankan. Jadi mereka membuat dua, dan mengatur CS untuk menunjuk ke deskriptor kode, dan sisanya (DS, ES, SS, dll) untuk menunjuk ke yang lain [2]. Namun keduanya menunjuk ke hal yang sama!

Orang yang mewawancarai Anda telah membuat asumsi tersembunyi bahwa ia tidak menyatakannya, dan itu adalah trik bodoh untuk ditarik.

Jadi tentang

P. Jadi, beri tahu saya segmen mana yang dibagikan?

Segmen tidak relevan dengan pertanyaan, setidaknya di Windows. Utas berbagi seluruh ruang alamat. Hanya ada 1 tumpukan segmen, SS, dan itu menunjuk ke hal-hal yang sama persis seperti yang dilakukan DS, ES, dan CS [2]. Yaitu seluruh ruang pengguna berdarah . 0-2GB. Tentu saja, itu tidak berarti utas hanya memiliki 1 tumpukan. Biasanya masing-masing memiliki tumpukan sendiri, tetapi segmen x86 tidak digunakan untuk tujuan ini.

Mungkin * nix melakukan sesuatu yang berbeda. Siapa tahu. Premis yang mendasari pertanyaan itu rusak.

1. Setidaknya untuk ruang pengguna.
2. Dari ntsd notepad:cs=001b ss=0023 ds=0023 es=0023

Secara umum, Thread disebut proses ringan. Jika kita membagi memori menjadi tiga bagian maka akan menjadi: Kode, data, dan Stack. Setiap proses memiliki bagian kode, data, dan tumpukan sendiri dan karena konteks ini, waktu sakelar agak tinggi. Untuk mengurangi waktu switching konteks, orang telah datang dengan konsep utas, yang membagi data dan segmen kode dengan utas / proses lain dan memiliki segmen STACK sendiri.

Suatu proses memiliki kode, data, tumpukan dan tumpukan segmen. Sekarang, Instruction Pointer (IP) dari utas atau utas menunjuk ke segmen kode dari proses. Segmen data dan tumpukan dibagi oleh semua utas. Sekarang bagaimana dengan area stack? Apa sebenarnya area tumpukan? Ini adalah area yang dibuat oleh proses hanya untuk menggunakan utasnya ... karena tumpukan dapat digunakan dengan cara yang jauh lebih cepat daripada tumpukan dll. Area tumpukan proses dibagi di antara utas, yaitu jika ada 3 utas, maka tumpukan area dari proses dibagi menjadi 3 bagian dan masing-masing diberikan kepada 3 utas. Dengan kata lain, ketika kita mengatakan bahwa setiap utas memiliki tumpukan sendiri, tumpukan itu sebenarnya merupakan bagian dari area tumpukan proses yang dialokasikan untuk setiap utas. Ketika sebuah utas menyelesaikan eksekusi, tumpukan utas tersebut direklamasi oleh proses. Faktanya, tidak hanya tumpukan proses yang dibagi di antara utas, tetapi semua set register yang menggunakan thread seperti SP, PC dan register negara adalah register dari proses. Jadi ketika harus berbagi, kode, data, dan area tumpukan dibagi, sedangkan area tumpukan hanya dibagi di antara utas.

Thread berbagi kode dan segmen data dan heap, tetapi mereka tidak membagikan stack.

Thread berbagi data dan kode sementara proses tidak. Tumpukan tidak dibagi untuk keduanya.

Proses juga dapat berbagi memori, lebih tepatnya kode, misalnya setelah a Fork(), tetapi ini adalah detail implementasi dan (sistem operasi) optimasi. Kode yang dibagikan oleh banyak proses akan (mudah-mudahan) menjadi duplikat pada penulisan pertama ke kode - ini dikenal sebagai copy-on-write . Saya tidak yakin tentang semantik yang tepat untuk kode utas, tetapi saya menganggap kode yang dibagikan.

           Utas proses

   Susun pribadi pribadi
   Data pribadi dibagikan
   Kode pribadi 1   dibagikan 2

¹ Kode ini secara logis pribadi tetapi mungkin bersama untuk alasan kinerja. ² Saya tidak yakin 100%.

Threads membagikan semuanya [1]. Ada satu ruang alamat untuk seluruh proses.

Setiap utas memiliki tumpukan dan registernya sendiri, tetapi semua tumpukan utas terlihat di ruang alamat bersama.

Jika satu utas mengalokasikan beberapa objek pada tumpukannya, dan mengirimkan alamat ke utas lain, keduanya akan memiliki akses yang sama ke objek tersebut.

Sebenarnya, saya baru saja memperhatikan masalah yang lebih luas: Saya pikir Anda membingungkan dua penggunaan segmen kata .

Format file untuk yang dapat dieksekusi (mis., ELF) memiliki bagian yang berbeda di dalamnya, yang dapat disebut sebagai segmen, yang berisi kode kompilasi (teks), data yang diinisialisasi, simbol tautan, info debug, dll. Tidak ada segmen tumpukan atau tumpukan di sini, karena itu hanya konstruksi runtime.

Segmen file biner ini dapat dipetakan ke dalam ruang alamat proses secara terpisah, dengan izin yang berbeda (mis. Read-only executable untuk kode / teks, dan copy-on-write yang tidak dapat dieksekusi untuk data yang diinisialisasi).

Area ruang alamat ini digunakan untuk tujuan yang berbeda, seperti alokasi tumpukan dan tumpukan utas, berdasarkan konvensi (diberlakukan oleh pustaka runtime bahasa Anda). Itu semua hanya memori, dan mungkin tidak tersegmentasi kecuali Anda menjalankan dalam mode 8086 virtual. Setiap tumpukan thread adalah sepotong memori yang dialokasikan pada waktu pembuatan thread, dengan alamat top stack saat ini disimpan dalam register penunjuk tumpukan, dan setiap utas menyimpan penunjuk tumpukannya sendiri bersama dengan register lainnya.

[1] OK, saya tahu: masker sinyal, TSS / TSD dll. Ruang alamat, termasuk semua segmen program yang dipetakan, masih dibagikan.

Dalam kerangka kerja x86, seseorang dapat membagi banyak segmen (hingga 2 ^ 16-1). Arahan ASM SEGMENT / ENDS memungkinkan ini, dan operator SEG dan OFFSET memungkinkan inisialisasi register segmen. CS: IP biasanya diinisialisasi oleh loader, tetapi untuk DS, ES, SS aplikasi bertanggung jawab dengan inisialisasi. Banyak lingkungan memungkinkan apa yang disebut "definisi segmen yang disederhanakan" seperti .code, .data, .bss, .stack dll. Dan, tergantung juga pada "model memori" (kecil, besar, padat dll.) Loader memulai register segmen demikian. Biasanya .data, .bss, .stack, dan segmen biasa lainnya (saya belum melakukan ini sejak 20 tahun jadi saya tidak ingat semua) dikelompokkan dalam satu kelompok tunggal - itulah sebabnya biasanya DS, ES dan SS menunjuk ke area yang sama, tetapi ini hanya untuk menyederhanakan hal-hal.

Secara umum, semua register segmen dapat memiliki nilai yang berbeda saat dijalankan. Jadi, pertanyaan wawancara itu benar: yang mana dari KODE, DATA, dan STACK yang dibagikan di antara utas. Manajemen heap adalah sesuatu yang lain - itu hanya urutan panggilan ke OS. Tetapi bagaimana jika Anda tidak memiliki OS sama sekali, seperti dalam sistem tertanam - dapatkah Anda masih memiliki / menghapus baru dalam kode Anda?

Saran saya kepada orang-orang muda - baca beberapa buku pemrograman perakitan yang bagus. Tampaknya kurikulum universitas sangat buruk dalam hal ini.

Selain memori global, utas juga berbagi sejumlah atribut lainnya (yaitu, atribut ini bersifat global untuk suatu proses, bukan khusus untuk utas). Atribut-atribut ini meliputi:

• ID proses dan ID proses induk;
• ID grup proses dan ID sesi;
• terminal pengendali;
• kredensial proses (ID pengguna dan grup);
• buka deskriptor file;
• rekam kunci yang dibuat menggunakan fcntl();
• disposisi sinyal;
• informasi terkait sistem file: umask, direktori kerja saat ini, dan direktori root;
• timer interval ( setitimer()) dan timer POSIX ( timer_create());
• Nilai sistem V semaphore undo ( semadj) (Bagian 47.8);
• batas sumber daya;
• Waktu CPU dikonsumsi (seperti yang dikembalikan oleh times());
• sumber daya yang dikonsumsi (seperti yang dikembalikan oleh getrusage()); dan
• nilai bagus (ditetapkan oleh setpriority()dan nice()).

Di antara atribut yang berbeda untuk setiap utas adalah yang berikut:

• ID utas (Bagian 29.5);
• topeng sinyal;
• data khusus utas (Bagian 31.3);
• tumpukan sinyal alternatif ( sigaltstack());
• variabel errno;
• lingkungan titik-mengambang (lihat fenv(3));
• kebijakan dan prioritas penjadwalan realtime (Bagian 35.2 dan 35.3);
• Afinitas CPU (spesifik Linux, dijelaskan dalam Bagian 35.4);
• kemampuan (khusus Linux, dijelaskan pada Bab 39); dan
• stack (variabel lokal dan informasi keterkaitan fungsi panggilan).

Kutipan dari: Antarmuka Pemrograman Linux: Buku Pegangan Pemrograman Sistem Linux dan UNIX, Michael Kerrisk , halaman 619

Thread berbagi heap (ada penelitian tentang heap spesifik thread) tetapi implementasi saat ini berbagi heap. (dan tentu saja kodenya)

Dalam prosesnya, semua utas berbagi sumber daya sistem seperti memori tumpukan dll. Sementara utas memiliki tumpukan sendiri

Jadi ans Anda harus menumpuk memori yang berbagi semua utas untuk suatu proses.