"Dulu aku mengira program itu selalu berjalan baris per baris. Setelah Modul 6, aku paham: OS bisa membuat banyak 'tugas' terlihat berjalan sekaligus — meskipun di CPU tunggal, itu hanya ilusi yang rapi."

Modul 6 mengajarkan dua konsep yang sangat fundamental: sekuensial (eksekusi baris demi baris) dan konkuren (beberapa proses "berjalan bersamaan" melalui penjadwalan). Di Xinu kita bisa mencoba keduanya dengan sangat jelas: ubah main.c, compile, jalankan backend VM, dan lihat perbedaannya di terminal. Penjelasan teknis dan langkah praktis di bawah ini mengikuti struktur praktikum dan mudah diikuti.

Inti konsep singkat (why this matters)

  • Sekuensial: CPU mengeksekusi instruksi satu-per-satu; kalau satu fungsi jalan terus (infinite loop), fungsi berikutnya nggak akan dieksekusi.
  • Konkuren: OS (melalui scheduler & syscall create()/resume()) membuat ilusi beberapa proses berjalan bersamaan—dengan satu CPU itu berupa interleaving, dan dengan multi-core bisa jadi nyata paralel.

Ringkasan Konsep

  • Sekuensial: program mengeksekusi perintah satu-per-satu — seperti orang tunggal yang menyelesaikan semua tugasnya sendiri. Jika salah satu tugas tak pernah selesai, yang lain tidak akan dikerjakan.
  • Konkuren: banyak proses/progam dibuat sehingga OS dapat menginterleaving eksekusinya — seperti beberapa pekerja bergantian memakai satu mesin untuk menyelesaikan pekerjaan masing-masing. Di CPU tunggal, ini ilusi paralelisme; pada multi-core, bisa benar-benar paralel.

Di Xinu, mekanisme utama untuk membuat proses baru adalah create() (menciptakan proses dalam status suspend) dan resume(pid) (menjadikan proses ready sehingga scheduler akan mengeksekusinya).

Persiapan sebelum eksperimen

Pastikan kamu sudah:

  1. Menjalankan Development-System VM (Ubuntu, user xinu, password xinurocks).
  2. Backend VM di VirtualBox siap dan konfigurasi serial/network sudah sesuai (Internal Network, path serial sama).
  3. Source Xinu tersedia di /home/xinu/xinu

Buka terminal di development VM. Semua perintah di bawah diasumsikan dijalankan dari home xinu.

1) Eksperimen A — Program Sekuensial

Goal: Buktikan bahwa fungsi yang dipanggil berurutan — jika fungsi pertama tidak pernah selesai, fungsi kedua tidak akan jalan.

Langkah 1 — Edit system/main.c

Buka main.c di editor (gedit/nano/vi):

None
gedit system/main.c

Ganti isinya (atau modifikasi) menjadi contoh sekuensial ini:

#include <xinu.h>

void sndA(void) {
    while (1) {
        kprintf("A\n");
        sleepms(1000);   /* tidur 1 detik */
    }
}

void sndB(void) {
    while (1) {
        kprintf("B\n");
        sleepms(1000);
    }
}

process main(void) {
    /* pemanggilan fungsi (bukan create) => sekuensial */
    sndA();    /* ini tidak pernah return karena loop infinite */
    sndB();    /* tidak akan pernah dieksekusi */
    return OK;
}

Catatan: Perbedaan kunci di sini adalah pemanggilan fungsi biasa (sndA(); sndB();) di dalam satu proses main, bukan membuat proses baru.

Langkah 2— Build & jalankan

None
cd ~/xinu/compile
make clean
make
sudo minicom   # akan membuka serial terminal; masukkan password xinurocks

Lalu di VirtualBox → Start backend.ova. Lihat terminal Minicom.

Hasil yang diharapkan

Output akan menampilkan baris A terus-menerus, tidak pernah muncul B:

None

Karena sndA() tidak pernah selesai (loop infinite), proses main tidak pernah lanjut ke pemanggilan sndB(). Ini adalah eksekusi sekuensial murni.

2) Eksperimen B — Program Konkuren

Goal: Membuat dua proses terpisah (A dan B) sehingga scheduler Xinu akan menjadwalkan keduanya dan output A dan B muncul bergantian.

Langkah 1 — Edit system/main.c untuk konkuren

gedit system/main.c
None

Ganti dengan kode konkuren berikut:

#include <xinu.h>

void sndA(void) {
    while (1) {
        kprintf("A\n");
        sleepms(1000);
    }
}

void sndB(void) {
    while (1) {
        kprintf("B\n");
        sleepms(1000);
    }
}

process main(void) {
    pid32 pidA, pidB;

    pidA = create(sndA, 1024, 20, "processA", 0);
    pidB = create(sndB, 1024, 20, "processB", 0);

    resume(pidA);
    resume(pidB);

    /* main bisa sleep atau menunggu, supaya tidak exit */
    while (1) {
        sleepms(5000);
    }

    return OK;
}

Penjelasan:

  • create() membuat proses baru yang dalam state suspended; ia mengembalikan PID.
  • resume(pid) mengubah state menjadi ready, sehingga scheduler akan mengeksekusinya.

Langkah 2 — Build & jalankan

cd ~/xinu/compile
make clean
make
sudo minicom

Start backend.ova di VirtualBox.

Hasil yang diharapkan

Terminal akan menampilkan pola bergantian A dan B:

None

Penjelasan: Xinu scheduler memilih proses yang ready dan menjalankannya bergantian sehingga tampak paralel (ilusi paralelism pada satu CPU). Jika sistem multicore, beberapa proses bisa benar-benar berjalan paralel.

3) Perbandingan: Kenapa sekuensial & konkuren berbeda secara runtime?

  • Pada sekuensial, hanya ada satu proses (main) sehingga CPU mengikuti alur fungsi di dalam proses itu. Jika fungsi tidak return, seluruh eksekusi berhenti di situ.
  • Pada konkuren, kita membuat lebih dari satu proses (melalui create()), dan scheduler OS bertanggung jawab melakukan context switch antar proses yang ready (fungsi resched() dan ctxsw di kernel Xinu). Ini menciptakan ilusi beberapa program berjalan bersamaan.

4) Eksperimen tambahan — pengaruh prioritas

Kamu bisa coba ubah prioritas proses pada create():

pidA = create(sndA, 1024, 50, "processA", 0);  // prioritas tinggi
pidB = create(sndB, 1024, 10, "processB", 0);  // prioritas rendah

Run ulang. Dengan prioritas berbeda, proses dengan prioritas lebih tinggi akan mendapat jatah CPU lebih sering, sehingga pola output akan didominasi A (prioritas 50) dibanding B. Ini memperlihatkan perbedaan antara timesharing vs realtime scheduling (waktu nyata) seperti dijelaskan modul.

"Melihat A terus-menerus di mode sekuensial membuatku merasakan betapa pentingnya struktur proses. Lalu, dengan dua baris create() + resume(), tiba-tiba Xinu berubah menjadi orkestra kecil — scheduler yang menjadi konduktor. Itu momen yang membuatku paham: konkurensi bukan sulap, tapi rekayasa cermat struktur data dan penjadwalan."

Modul 6 bukan hanya latihan mengetik dan compile — ia latihan berpikir, memikirkan siapa yang mendapat CPU, kapan, dan mengapa. Setelah modul ini, kamu akan lebih siap memahami topik lanjutan seperti sinkronisasi (semaphore) dan race condition yang akan kita pelajari di modul berikutnya.