Eksplorasi Concurrency: Implementasi Semaphores dan Mutex pada Xinu OS — Praktikum Sistem Operasi 8

Pendahuluan

Dalam sistem operasi multitasking seperti Xinu, manajemen konkurensi adalah aspek krusial. Ketika beberapa proses berjalan secara bersamaan dan mengakses sumber daya yang sama (shared resources), risiko terjadinya race condition sangat tinggi. Untuk mengatasi hal ini, kita memerlukan mekanisme sinkronisasi. Dua alat utama yang digunakan dalam Xinu adalah Semaphore dan Mutex. Laporan ini akan membahas bagaimana keduanya diimplementasikan untuk menyelesaikan masalah klasik Producer-Consumer.

1. Memahami Semaphore pada Xinu OS

Semaphore dalam Xinu adalah sebuah variabel bertipe integer yang digunakan untuk mengontrol akses ke sumber daya bersama. Xinu menyediakan beberapa fungsi utama untuk memanipulasi semaphore:

• **semcreate(int count)**: Membuat semaphore baru dengan nilai awal tertentu.
• **wait(sid sem)*: Mengurangi nilai semaphore. Jika nilai $\le 0$, proses akan masuk ke antrean blocked*.
• **signal(sid sem)**: Menambah nilai semaphore dan membangunkan proses yang sedang menunggu di antrean.
• **semdelete(sid sem)**: Menghapus semaphore dari sistem.

2. Studi Kasus: Masalah Producer-Consumer

Salah satu implementasi paling umum dari semaphore adalah pada skema Infinite/Finite Buffer. Berdasarkan kode yang kita pelajari, terdapat tiga semaphore utama yang digunakan:

1. Semaphore s (Mutex): Diinisialisasi dengan nilai 1 untuk memastikan Mutual Exclusion agar hanya satu proses yang mengakses buffer pada satu waktu.
2. Semaphore n (Full): Diinisialisasi dengan 0 untuk menghitung jumlah item yang tersedia di buffer.
3. Semaphore e (Empty): Diinisialisasi dengan kapasitas maksimal buffer (misal: 5) untuk menghitung slot kosong yang tersisa.

Alur Kerja Thread:

• Thread Producer: Memproduksi item, melakukan semWait(e) untuk memastikan ada ruang kosong, lalu semWait(s) untuk masuk ke critical section, memasukkan data, dan diakhiri dengan semSignal(s) serta semSignal(n) untuk memberitahu Consumer bahwa data tersedia.
• Thread Consumer: Melakukan semWait(n) untuk menunggu ketersediaan data, lalu semWait(s) untuk mengambil data secara eksklusif, dan diakhiri dengan semSignal(s) serta semSignal(e) untuk mengosongkan slot kembali.

3. Analisis Masalah dan Sinkronisasi

Berdasarkan pengujian pada kode program, terdapat beberapa kondisi kritis yang harus diperhatikan:

• Kapan Proses Terhenti (Block)?
• Producer akan terhenti (block) saat buffer penuh, yaitu ketika nilai semaphore e mencapai 0.
• Consumer akan terhenti (block) jika mencoba mengambil data saat buffer kosong, yaitu ketika nilai semaphore n atau y masih 0.

Efek Kesalahan Inisialisasi:

• Jika Mutex (x atau s) diberi nilai awal 0, maka akan terjadi Deadlock karena tidak ada proses yang bisa masuk ke critical section.
• Jika Mutex diberi nilai $> 1$ (misal: 2), maka akan terjadi Race Condition karena lebih dari satu proses dapat memodifikasi buffer secara bersamaan, yang berisiko merusak integritas data.

4. Implementasi Kode pada Xinu

Berikut adalah cuplikan logika implementasi dalam bahasa C untuk Xinu OS:

/* Inisialisasi Semaphore */
sid s = semcreate(1); // Mutex
sid n = semcreate(0); // Count item
sid e = semcreate(5); // Count empty slots

void producer() {
    while(true) {
        produce();
        wait(e);
        wait(s);
        append(); // Critical Section
        signal(s);
        signal(n);
    }
}

void consumer() {
    while(true) {
        wait(n);
        wait(s);
        take(); // Critical Section
        signal(s);
        signal(e);
        consume();
    }
}

Kesimpulan

Penggunaan semaphore dan mutex pada Xinu OS sangat efektif untuk menjamin keamanan data dalam lingkungan concurrent. Dengan mengatur nilai inisialisasi yang tepat pada semaphore s, n, dan e, kita dapat mencegah terjadinya race condition dan memastikan aliran data antara producer dan consumer berjalan secara sinkron tanpa menyebabkan deadlock selama kapasitas buffer dikelola dengan benar.