GNU - Sistem Pengoperasian Bebas Hakmilik

Amnya GNU merupakan pakej perisian yang diuruskan oleh Free Software Foundation (FSF) - https://www.fsf.org/. FSF merupakan sebuah yayasan yang diasaskan oleh Richard Stallman, yang mana merupakan seorang pengatur cara komputer dan aktivis. Stallman dianggap ikon dalam kalangan mereka yang memperjuangkan idealisme perisian bebas (free software) dan berasaskan kod sumber terbuka (open source). 

Nama GNU merupakan akronim kepada 'GNU's not Unix', dan disebut dengan sebutan /gnu/. Mungkin kerana persamaan sebutan, GNU mengetengahkan haiwan gnu sebagai maskot rasminya. Lukisan di bawah ini merupakan lambang maskot GNU yang dihasilkan oleh Etienne Suvasa.

Berbanding sistem pengoperasian lain, GNU dianggap unik kerana GNU bukan semata-mata sistem pengoperasian atau perisian tetapi turut dianggap projek dan manifestasi kepada idealisme 'semua perisian adalah bebas untuk semua orang'.

Pakej GNU (https://directory.fsf.org) merupakan koleksi perisian lengkap dan bebas hak milik. Asalnya koleksi ini bertujuan menyediakan sistem pengoperasian selain menawarkan pelbagai perisian utiliti dan aplikasi yang biasa ditemui dalam kebanyakan sistem (spesifiknya, yang berasaskan Unix). 

Sehingga kini, selain sistem pengoperasian, pakej GNU turut menaungi lebih dari 16,000 projek perisian merangkumi perisian sistem, utiliti dan aplikasi termasuk pemproses perkataan, penyunting grafik, pengkompil dan lain-lain. Pendek kata, dengan memilih pelbagai perisian percuma GNU dan memasangnya ke dalam sebuah komputer, komputer tersebut boleh beroperasi sepenuhnya dan memenuhi kebanyakan keperluan asas pengguna, selain perisian itu bebas untuk dikongsi dan dikemas kini.

Sesiapa saja bebas menggunakan, menyalin, mengedar dan menyunting perisian dalam pakej GNU, selagi pengguna mematuhi syarat dan terma dalam Lesen Awam Umum (General Public License) atau GPL, yang digelar sebagai copyleft. Syarat ini memastikan perisian GNU kekal bebas walaupun selepas disunting.

Walau bagaimanapun GNU masih dikenali sebagai pakej sistem pengoperasian. Sistem pengoperasian GNU menggunakan kernel libre Linux, dan turut dikenali sebagai GNU/Linux. Ini kerana GNU belum mempunyai kernel sendiri. Pakej ini boleh dimuat turun dari https://www.gnu.org/gnu/gnu.html. Secara keseluruhan, sistem pengoperasian GNU/Linux nampak sama saja dengan pakej Linux dan sistem berasaskan Unix.

Selain menggunakan kernel Linux, GNU ada menaungi projek pembangunan kernelnya sendiri yang dinamakan Hurd. Hurd ialah kernel yang dibangunkan menggunakan rekabentuk mikrokernel dan sistem pengoperasian Mach. Tetapi disebabkan Hurd masih dianggap dalam peringkat pembangunan, maka GNU menggunakan kernel Linux. Pada masa depan Hurd dijangka akan dapat digunakan dan menggantikan kernel Linux sebagai kernel GNU.

.

Eksperimen simulasi Penjadualan Proses menggunakan aplikasi ALExSIM (USAS)

Alhamdulillah, saya berjaya juga menyiapkan projek terbaru iaitu pensimulasi algoritma penjadualan proses yang dinamakan ALExSIM (USAS), atau ringkasnya USAS. 

Aplikasi ini dalam tempoh percubaan dan boleh diperolehi dari laman khas ALExSIM (USAS). Di bawah ini adalah contoh antaramuka daripada aplikasi tersebut.

Contoh antaramuka ALExSIM (USAS)

Aplikasi USAS ini sebenarnya bukanlah unik atau yang pertama seumpamanya. Terdapat beberapa aplikasi pensimulasi penjadualan proses seperti USAS yang telahpun ada. Walau bagaimanapun saya tetap bina USAS sebagai usaha menambahkan pilihan alat aplikasi sedia ada. Saya dapat motivasi membina USAS daripada aktiviti pengaturcaraan yang pernah saya bincangkan sebelum ini (berkenaan menggunakan JFreeChart dalam Java)

USAS juga dibina dengan harapan untuk memudahkan pelajar-pelajar saya dan sesiapa saja yang mempelajari kursus Sistem Pengoperasian untuk mendalami topik Penjadualan Proses (salah satu topik dalam kursus tersebut). Bahkan saya sendiri menggunakan USAS ini untuk bereksperimen dan menyediakan skema jawapan untuk soalan peperiksaan berkaitan topik ini.

Mudah-mudahan aplikasi ini ada manfaatnya.

Tutorial - Menggunakan JFreeChart untuk simulasi penjadualan proses

Pengenalan JFreeChart

JFreeChart ialah pustaka kod sumber terbuka (open source) yang dibangunkan oleh David Gilbert sejak tahun 2000. Pustaka ini boleh diperoleh dan digunakan secara percuma (tetapi perlu menyatakan hakcipta pemilik/pencipta asal). 

Fungsi pustaka ini ialah untuk membolehkan pengatur cara menghasilkan carta melalui atur cara Java. Contoh-contoh carta yang boleh dihasilkan oleh pustaka ini boleh dirujuk di laman JFreeChart.org. Antaranya termasuklah seperti yang dipaparkan di bawah:

sumber: JFreeChart.org

Tutorial - membina carta Gantt untuk simulasi penjadualan proses.

Tutorial ini bertujuan menunjukkan cara-cara menggunakan JFreeChart dalam aturcara Java untuk membina aplikasi simulasi penjadualan proses.

Contoh aplikasi yang ditunjukkan dalam tutorial ini ialah aplikasi simulasi penjadualan proses untuk penggunaan CPU (Central Processing Unit, atau Unit Pemprosesan Pusat). Aplikasi simulasi ini akan membentuk 5 proses yang akan dijadualkan (untuk menggunakan 'CPU') menggunakan algoritma Round-Robin. Hasil simulasi penjadualan akan ditunjukkan seperti dalam gambarajah di bawah, yang mengandungi 1 tetingkap untuk memaparkan carta Gantt, dan maklumat terperinci dipaparkan dalam paparan konsol (console).

Tutorial ini melibatkan tiga peringkat berikut:

• Memasukkan pustaka JFreeChart dalam projek
• Memasukkan panggilan pustaka JFreeChart yang asas ke dalam atur cara Java
• Membina aplikasi simulasi penjadualan

.

Peringkat 1: Memasukkan pustaka JFreeChart dalam projek.

Untuk menggunakan pustaka JFreeChart, kita boleh mendapatkan kod sumber sepenuhnya dan kemudian mengkompilnya ke dalam bentuk fail JAR (Java ARchive). Walau bagaimanapun kita boleh terus mendapatkan fail JAR yang sudah siap dikompil, kemudian memasukkannya ke dalam projek aplikasi Java yang kita bina. 

Untuk tutorial ini, kita perlukan dua fail JAR berikut :

• jCommon.jar
• jFreeChart.jar

Versi terkini fail-fail ini boleh dimuat turun dari laman web JFreeChart.org. 

Berikut ialah langkah memasukkan fail JAR ke dalam projek (IDE Netbeans):

• Langkah 1: Muat turun dan letakkan fail-fail JAR tersebut ke dalam sebuah folder/direktori.
• Langkah 2: Buka tetapan (setting) projek, dengan klik butang kanan pada nama projek dan pilih Properties (merujuk 'Project Properties').
• Langkah 3: Dalam tetingkap dialog yang muncul, klik Libraries, dan pilih tab Compile. Tekan butang Add JAR/folder dan cari semula folder yang mengandungi fail-fail JAR yang sudah dimuat turun.

.

Peringkat 2: Memasukkan panggilan pustaka JFreeChart yang asas dalam atur cara Java.

Nota : JFreeChart menggunakan pustaka Java Swing, iaitu salah satu platform atau pustaka GUI bagi Java. Diandaikan anda tahu cara-cara menggunakan Java Swing. Jika tidak tahu, anda perlu belajar dahulu cara menggunakan Java Swing.

Untuk memahami konsep JFreeChart, kita akan bina satu aplikasi asas menggunakan JFreeChart. Dalam aplikasi asas ini, kita membina sebuah kelas JFrame (kelas dari Java Swing) dan memaparkan sebuah carta Gantt di dalamnya. 

Umumnya, untuk membina carta Gantt menggunakan JFreeChart, 

1. Kita perlu sediakan satu siri data menggunakan kelas TaskSeries, dan dimasukkan ke dalam sebuah koleksi dari kelas TaskSeriesCollection (IntervalCategoryDataset ialah super-kelas kepada kelas ini).
   
   

   ...     private IntervalCategoryDataset buildChartDataset()      {                  // Bina beberapa siri data         TaskSeries series = new TaskSeries("Data Series 1");         Task t1 = new Task("T1", new SimpleTimePeriod( 0, 100 ));           series.add( t1 );         Task t2 = new Task("T2", new SimpleTimePeriod( 110, 180 ));          series.add( t2 );         Task t3 = new Task("T3", new SimpleTimePeriod( 180, 220 ));          series.add( t3 );         TaskSeriesCollection dataset = new TaskSeriesCollection();         dataset.add(series);                  return dataset;     } ...

2. Set data ini akan kita jadikan ke dalam bentuk carta menggunakan metod dari kelas statik ChartFactory.createGanttChart(). Metod ini menghasilkan sebuah objek dari jenis kelas JFreeChart.
   
   

   ...     public TestChart(String title) {         super(title);         // Bina data set untuk carta         IntervalCategoryDataset dataset = buildChartDataset();         // Create chart         JFreeChart chart = ChartFactory.createGanttChart(                                 "Simple Gantt Chart",    // Tajuk                                 "Task",                  // Label Y-Axis                                 "Timeline",              // Label X-Axis                                 dataset);         // set x-axis range supaya bermula dengan 0         ( chart.getCategoryPlot() ).setRangeAxis(new NumberAxis());   ...

3. Objek carta yang terhasil dari metod statik ChartFactory.createGanttChart() perlu dimasukkan ke dalam sebuah container dari kelas  JPanel. Container yang mengandungi carta akan dimasukkan ke dalam JFrame untuk dipaparkan.
   
   

   ...         ChartPanel panel = new ChartPanel(chart);   // tambah ke dalam panel          setContentPane(panel);                      // paparkan panel ...

Atur cara di bawah menunjukkan keseluruhan atur cara yang menggunakan langkah-langkah yang dinyatakan ini.

Output daripada atur cara ini ialah seperti berikut:

Peringkat 3: Membina aplikasi simulasi penjadualan.

Setelah mengetahui bagaimana hendak membina carta menggunakan JFreeChart, kita gabungkan kemudahan ini untuk membina simulasi penjadualan proses.

Algoritma Penjadualan Proses

Penjadualan proses ialah antara tugas utama yang dijalankan oleh sistem pengoperasian (OS) dalam mengurus perlaksanaan atur cara dan program komputer. Penjadualan proses boleh dilakukan dengan menggunakan pelbagai jenis algoritma. Antara algoritma penjadualan proses yang asas ialah First-come-first-serve (FCFS), Round-Robin (RR), Shortest-Job-First (SJF) dan Priority-based. Kod atur cara berikut ialah sebahagian atur cara yang mengandungi implementasi algoritma RR (Lihat kod atur cara penuh dipaparkan di bawahnya):

...      private Process[] simulateRR(Process[] pt, int quantum)     {         // RR-queue, to manage the round-robin scheduling         class RRQItem {             public Process process;             public int remaining;             public int stopped;         }         Queue<RRQItem> rrQ = new LinkedList();   // Round-Robin queue         int clk_tick = 0;                        // reset clk_tick         int cpu_tick = 0;             // timer for running process         boolean cpu_idle = true;      // if not idle, then CPU is busy         int totDone = 0;         while(totDone < pt.length) {             // is it time to execute (submit to queue) ?             for(int p=0; p < pt.length; p++ ) {                 if (clk_tick == pt[p].arrivalTime) {                     // put inside RR-queue                     RRQItem item = new RRQItem();                     item.process = pt[p];                     item.remaining = pt[p].burstTime;                     item.stopped = pt[p].arrivalTime;                     rrQ.add(item);                 }             }             if(!cpu_idle) {                 cpu_tick--;           // deplete cpu burst time                 if(cpu_tick <= 0) {   // if timeout                     // remove currently running process                     RRQItem running = rrQ.remove();                     cpu_idle = true;                     if(running.remaining > 0) {       // if not yet finish                         running.stopped = clk_tick;   // record when this process                                                       //   is stopped                         running.process.numOfTimesStopped++;   // record stoppage                                                                //   count                         rrQ.add(running);             // put back into queue                     } else {                         // process finish, calculate turnaround time                         running.process.turnaroundTime =                                 clk_tick - running.process.arrivalTime;                         totDone++;                     }                 }             }             // if CPU idle, and no process is running             if(cpu_idle) {                 // submit next remaining process in queue                 if(!rrQ.isEmpty()) {                     RRQItem front = rrQ.peek();            // check who is at                                                            //   the front of Q                     if(front.process.startTime < 0) {      // record the first                                                            //   time process start                         front.process.startTime = clk_tick;  // record starting                                                              //   time                     }                     front.process.waitingTime += clk_tick - front.stopped;                     // submit and set for how long is the execution time                     cpu_idle = false;                     cpu_tick = (front.remaining >= quantum ? quantum :                                 front.remaining);                     Process part = new Process( "" + front.process.id + "_" +                               front.process.subtask.size(), cpu_tick, clk_tick);                     part.startTime = clk_tick;                     // record waiting time for this part                     part.waitingTime = clk_tick - front.stopped;                                              // add new part (sub-process)                     front.process.subtask.add( part );                                                           // update remaining time for this process                     front.remaining -= cpu_tick;                 }             }             clk_tick++;                     // update clk_tick         }         return pt;    }    ...

Simulasi Penjadualan Proses 

Berikut ialah atur cara penuh Java yang digunakan untuk menghasilkan simulasi penjadualan proses menggunakan algoritma Round-Robin.

Output yang dipaparkan daripada aplikasi simulasi penjadualan proses:

FreeBSD - sistem pengoperasian berasaskan UNIX

Kita biasa dengar Windows dalam PC atau MacOS dalam komputer Apple. Sebenarnya ada sistem pengoperasian (OS) lain yang popular dalam kalangan peminat sistem komputer tetapi jarang didengari dalam kalangan pengguna biasa. Antaranya ialah UNIX.

UNIX diperkenalkan pada 1969 dan menjadi popular kerana 1) OS pertama dibangunkan menggunakan bahasa paras tinggi sepenuhnya (iaitu bahasa C), 2) diedarkan bersama kod sumber, 3) disasarkan kepada komputer murah (PDP-11, ketika itu PC belum wujud). Versi terawal UNIX dibangunkan oleh Ken Thomson dan Dennis Ritchie, yang juga saintis yang mencipta bahasa pengaturcaraan C.

Populariti UNIX turut mendorong kemunculan versi-versi OS derivasi daripadanya. Antara OS tersebut ialah MacOS (Darwin, iaitu sistem pengoperasian dalam komputer peribadi Apple Macintosh) LINUX (OS untuk PC yang merupakan implementasi semula UNIX oleh Linus Torvald), dan BSD (Berkeley Software Distribution, versi UNIX yang dibangunkan dan diperbaiki oleh kumpulan penyelidikan sistem komputer atau CSRG di Universiti Berkeley, California).

BSD menjadi popular kerana dibangunkan secara bersama oleh komuniti (berbanding versi UNIX lain yang berasaskan perniagaan). Kini BSD disaingi oleh LINUX yang juga menggunakan konsep sumbangan komuniti dalam pembangunannya. OS ini digunakan bukan saja untuk komputer peribadi, tetapi juga komputer-komputer lain seperti pelayan, superkomputer dan untuk sistem terbenam (embedded).

BSD menerbitkan sekurang-kurangnya 3 aliran iaitu yang terawal NetBSD, kemudian FreeBSD dan OpenBSD. NetBSD ialah cabang yang muncul daripada versi 4.4BSD (juga dinamakan Networking 1 dan Networking 2). FreeBSD ialah cabang versi BSD terawal yang percuma sepenuhnya. Manakala OpenBSD ialah cabang BSD yang menumpukan kepada ciri keselamatan dalam OS.

FreeBSD kini diselenggara oleh FreeBSD Foundation dan boleh dimuat turun secara percuma dari laman web FreeBSD (link).